diff --git a/__tests__/app/identityPageSSR.test.tsx b/__tests__/app/identityPageSSR.test.tsx
new file mode 100644
index 0000000000..7a76fe22c7
--- /dev/null
+++ b/__tests__/app/identityPageSSR.test.tsx
@@ -0,0 +1,367 @@
+import { act, render, screen } from "@testing-library/react";
+import type { Page as PageWithCount } from "@/helpers/Types";
+import type {
+  CicStatement,
+  RatingWithProfileInfoAndLevel,
+} from "@/entities/IProfile";
+import type { IdentityTabParams } from "@/app/[user]/identity/_lib/identityShared";
+import {
+  ProfileActivityFilterTargetType,
+  ProfileRatersParamsOrderBy,
+  RateMatter,
+} from "@/enums";
+import { SortDirection } from "@/entities/ISort";
+import type { CountlessPage } from "@/helpers/Types";
+import type { ProfileActivityLog } from "@/entities/IProfile";
+
+const hydratorPropsSpy = jest.fn();
+const layoutPropsSpy = jest.fn();
+
+jest.mock("@/helpers/server.app.helpers", () => ({
+  getAppCommonHeaders: jest.fn(),
+}));
+
+jest.mock("@/helpers/server.helpers", () => {
+  const actual = jest.requireActual("@/helpers/server.helpers");
+  return {
+    ...actual,
+    getUserProfile: jest.fn(),
+    userPageNeedsRedirect: jest.fn(),
+    getProfileCicStatements: jest.fn(),
+    getProfileCicRatings: jest.fn(),
+    getUserProfileActivityLogs: jest.fn(),
+  };
+});
+
+jest.mock("@/components/user/layout/UserPageLayout", () => {
+  const React = require("react");
+  return {
+    __esModule: true,
+    default: (props: any) => {
+      layoutPropsSpy(props);
+      return React.createElement(
+        "div",
+        { "data-testid": "layout" },
+        props.children
+      );
+    },
+  };
+});
+
+jest.mock("@/components/user/identity/UserPageIdentityHydrator", () => {
+  const React = require("react");
+  return {
+    __esModule: true,
+    default: (props: any) => {
+      hydratorPropsSpy(props);
+      return React.createElement("div", {
+        "data-testid": "identity-hydrator",
+      });
+    },
+  };
+});
+
+jest.mock(
+  "@/components/user/identity/statements/UserPageIdentityStatements",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props: any) => {
+        return React.createElement("div", {
+          "data-testid": "identity-statements",
+        });
+      },
+    };
+  }
+);
+
+jest.mock(
+  "@/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props: any) => {
+        if (props.initialParams?.given) {
+          return React.createElement("div", {
+            "data-testid": "identity-cic-given",
+          });
+        }
+        return React.createElement("div", {
+          "data-testid": "identity-cic-received",
+        });
+      },
+    };
+  }
+);
+
+jest.mock(
+  "@/components/user/identity/activity/UserPageIdentityActivityLog",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: (props: any) => {
+        return React.createElement("div", {
+          "data-testid": "identity-activity",
+        });
+      },
+    };
+  }
+);
+
+jest.mock(
+  "@/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: ({ children }: { children: React.ReactNode }) =>
+        React.createElement(
+          "div",
+          { "data-testid": "identity-setup" },
+          children
+        ),
+    };
+  }
+);
+
+jest.mock(
+  "@/components/user/user-page-header/userPageHeaderData",
+  () => {
+    const actual = jest.requireActual(
+      "@/components/user/user-page-header/userPageHeaderData"
+    );
+    return {
+      __esModule: true,
+      ...actual,
+      fetchProfileEnabledLog: jest.fn(),
+      fetchFollowersCount: jest.fn(),
+    };
+  }
+);
+
+import Page, {
+  IdentityTabContent,
+} from "@/app/[user]/identity/page";
+import { getAppCommonHeaders } from "@/helpers/server.app.helpers";
+import {
+  getProfileCicRatings,
+  getProfileCicStatements,
+  getUserProfile,
+  getUserProfileActivityLogs,
+  userPageNeedsRedirect,
+} from "@/helpers/server.helpers";
+import {
+  fetchFollowersCount,
+  fetchProfileEnabledLog,
+} from "@/components/user/user-page-header/userPageHeaderData";
+
+const buildIdentityData = () => {
+  const statements = [{ id: "statement-1" }] as CicStatement[];
+  const cicGiven: PageWithCount<RatingWithProfileInfoAndLevel> = {
+    count: 1,
+    data: [
+      { id: "given-1" } as unknown as RatingWithProfileInfoAndLevel,
+    ],
+    page: 1,
+    next: false,
+  };
+  const cicReceived: PageWithCount<RatingWithProfileInfoAndLevel> = {
+    count: 2,
+    data: [
+      { id: "received-1" } as unknown as RatingWithProfileInfoAndLevel,
+    ],
+    page: 1,
+    next: false,
+  };
+  const activityLog: CountlessPage<ProfileActivityLog> = {
+    page: 1,
+    next: false,
+    data: [{ id: "log-1" } as ProfileActivityLog],
+  };
+  const params: IdentityTabParams = {
+    activityLogParams: {
+      page: 1,
+      pageSize: 10,
+      logTypes: [],
+      matter: null,
+      targetType: ProfileActivityFilterTargetType.ALL,
+      handleOrWallet: "alice",
+      groupId: null,
+    },
+    cicGivenParams: {
+      page: 1,
+      pageSize: 7,
+      given: true,
+      order: SortDirection.DESC,
+      orderBy: ProfileRatersParamsOrderBy.RATING,
+      handleOrWallet: "alice",
+      matter: RateMatter.NIC,
+    },
+    cicReceivedParams: {
+      page: 1,
+      pageSize: 7,
+      given: false,
+      order: SortDirection.DESC,
+      orderBy: ProfileRatersParamsOrderBy.RATING,
+      handleOrWallet: "alice",
+      matter: RateMatter.NIC,
+    },
+  };
+
+  return { statements, cicGiven, cicReceived, activityLog, params };
+};
+
+describe("identity page SSR streaming", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("prepares layout props while deferring identity data fetches", async () => {
+    const headers = { "x-test": "identity" };
+    const profile = { handle: null, wallets: [], id: 99 } as any;
+    const profileLog = {
+      page: 1,
+      next: false,
+      data: [{ created_at: "2024-01-01T00:00:00Z" }],
+    };
+    const followersCount = 3;
+
+    (getAppCommonHeaders as jest.Mock).mockResolvedValue(headers);
+    (getUserProfile as jest.Mock).mockResolvedValue(profile);
+    (userPageNeedsRedirect as jest.Mock).mockReturnValue(null);
+    (getProfileCicStatements as jest.Mock).mockResolvedValue([]);
+    (getProfileCicRatings as jest.Mock).mockResolvedValue({
+      count: 0,
+      data: [],
+      page: 1,
+      next: false,
+    });
+    (getUserProfileActivityLogs as jest.Mock).mockResolvedValue({
+      page: 1,
+      next: false,
+      data: [],
+    });
+    (fetchProfileEnabledLog as jest.Mock).mockResolvedValue(profileLog);
+    (fetchFollowersCount as jest.Mock).mockResolvedValue(followersCount);
+
+    const element = await Page({
+      params: Promise.resolve({ user: "Alice" }),
+      searchParams: Promise.resolve({ q: "test" }),
+    } as any);
+
+    render(element);
+
+    expect(getUserProfile).toHaveBeenCalledWith({
+      user: "alice",
+      headers,
+    });
+    expect(userPageNeedsRedirect).toHaveBeenCalledWith({
+      profile,
+      req: { query: { user: "Alice", q: "test" } },
+      subroute: "identity",
+    });
+    expect(fetchProfileEnabledLog).toHaveBeenCalledWith({
+      handleOrWallet: "alice",
+      headers,
+    });
+    expect(fetchFollowersCount).toHaveBeenCalledWith({
+      profileId: profile.id,
+      headers,
+    });
+    expect(layoutPropsSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        profile,
+        handleOrWallet: "alice",
+        initialStatements: [],
+        profileEnabledAt: "2024-01-01T00:00:00.000Z",
+        followersCount,
+      })
+    );
+    expect(screen.getByTestId("identity-tab-fallback")).toBeInTheDocument();
+  });
+
+  it("streams identity tab sections independently", async () => {
+    const headers = { "x-test": "identity" };
+    const profile = { handle: null, wallets: [], id: 99 } as any;
+    const { statements, cicGiven, cicReceived, activityLog, params } =
+      buildIdentityData();
+
+    (getProfileCicStatements as jest.Mock).mockResolvedValue(statements);
+    (getProfileCicRatings as jest.Mock).mockImplementation(
+      async ({
+        params: ratingsParams,
+      }: {
+        params: IdentityTabParams["cicGivenParams"];
+      }) => (ratingsParams.given ? cicGiven : cicReceived)
+    );
+    (getUserProfileActivityLogs as jest.Mock).mockResolvedValue(activityLog);
+
+    const content = await IdentityTabContent({
+      profile,
+      handleOrWallet: "alice",
+      headers,
+    });
+
+    render(<div>{content}</div>);
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+
+    expect(getProfileCicStatements).toHaveBeenCalledWith({
+      handleOrWallet: "alice",
+      headers,
+    });
+
+    const ratingsCalls = (getProfileCicRatings as jest.Mock).mock.calls;
+    expect(ratingsCalls).toHaveLength(2);
+    expect(ratingsCalls[0][0]).toEqual(
+      expect.objectContaining({
+        handleOrWallet: "alice",
+        headers,
+        params: params.cicGivenParams,
+      })
+    );
+    expect(ratingsCalls[1][0]).toEqual(
+      expect.objectContaining({
+        handleOrWallet: "alice",
+        headers,
+        params: params.cicReceivedParams,
+      })
+    );
+
+    expect(getUserProfileActivityLogs).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers,
+      })
+    );
+
+    expect(screen.getByTestId("identity-header")).toBeInTheDocument();
+    expect(
+      screen.getByTestId("identity-raters-skeleton-given")
+    ).toBeInTheDocument();
+    expect(
+      screen.getByTestId("identity-raters-skeleton-received")
+    ).toBeInTheDocument();
+    expect(
+      screen.getAllByText((_, node) =>
+        Boolean(node?.className?.includes?.("tw-animate-pulse"))
+      ).length
+    ).toBeGreaterThan(
+      0
+    );
+  });
+});
+jest.mock(
+  "@/components/user/identity/header/UserPageIdentityHeader",
+  () => {
+    const React = require("react");
+    return {
+      __esModule: true,
+      default: () =>
+        React.createElement("div", { "data-testid": "identity-header" }),
+    };
+  }
+);
diff --git a/__tests__/components/profile-activity/ProfileName.test.tsx b/__tests__/components/profile-activity/ProfileName.test.tsx
index 5072153e05..3c0b7fe8b1 100644
--- a/__tests__/components/profile-activity/ProfileName.test.tsx
+++ b/__tests__/components/profile-activity/ProfileName.test.tsx
@@ -1,6 +1,5 @@
-import ProfileName, {
-  ProfileNameType,
-} from "@/components/profile-activity/ProfileName";
+import ProfileName from "@/components/profile-activity/ProfileName";
+import { ProfileNameType } from "@/components/profile-activity/profileName.types";
 import { useIdentity } from "@/hooks/useIdentity";
 import { render, screen } from "@testing-library/react";
 import { useParams } from "next/navigation";
diff --git a/__tests__/components/profile-activity/list/ProfileActivityLogsItem.test.tsx b/__tests__/components/profile-activity/list/ProfileActivityLogsItem.test.tsx
index 6d1881438b..d3717a7c84 100644
--- a/__tests__/components/profile-activity/list/ProfileActivityLogsItem.test.tsx
+++ b/__tests__/components/profile-activity/list/ProfileActivityLogsItem.test.tsx
@@ -82,9 +82,18 @@ describe("ProfileActivityLogsItem", () => {
     ).toBeInTheDocument();
   });
 
-  it("throws for unknown type", () => {
-    expect(() =>
-      render(<ProfileActivityLogsItem log={{ type: "x" } as any} user={null} />)
-    ).toThrow();
+  it("renders fallback for unknown type", () => {
+    render(
+      <ProfileActivityLogsItem
+        log={{ id: "unknown", type: "x", created_at: "2024-01-01T00:00:00Z" } as any}
+        user={null}
+      />
+    );
+    expect(
+      document.querySelector('[data-testid="RATE"]')
+    ).not.toBeInTheDocument();
+    expect(
+      document.querySelector('[data-testid="unknown-identity-activity"]')
+    ).toBeInTheDocument();
   });
 });
diff --git a/__tests__/components/react-query-wrapper/ReactQueryWrapper.test.tsx b/__tests__/components/react-query-wrapper/ReactQueryWrapper.test.tsx
index bc59f55893..5037569d64 100644
--- a/__tests__/components/react-query-wrapper/ReactQueryWrapper.test.tsx
+++ b/__tests__/components/react-query-wrapper/ReactQueryWrapper.test.tsx
@@ -2,6 +2,9 @@ import React, { useContext } from 'react';
 import { render, act } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import ReactQueryWrapper, { ReactQueryWrapperContext, QueryKey } from '@/components/react-query-wrapper/ReactQueryWrapper';
+import { RateMatter, ProfileRatersParamsOrderBy, ProfileActivityFilterTargetType } from '@/enums';
+import { SortDirection } from '@/entities/ISort';
+import { convertActivityLogParams } from '@/helpers/profile-logs.helpers';
 
 jest.mock('@/helpers/Helpers', () => ({ ...jest.requireActual('../../../helpers/Helpers'), wait: jest.fn(() => Promise.resolve()) }));
 
@@ -23,6 +26,7 @@ type ContextType = {
   onGroupChanged: (params: { groupId: string }) => void;
   onIdentityBulkRate: () => void;
   invalidateNotifications: () => void;
+  initProfileIdentityPage: (params: any) => void;
 };
 
 const createTestSetup = () => {
@@ -51,6 +55,167 @@ describe('ReactQueryWrapper context', () => {
     expect(client.getQueryData([QueryKey.PROFILE, '0x1'])).toEqual(profile);
   });
 
+  it('initProfileIdentityPage primes logs, raters, and statements caches', () => {
+    const { client, ctx } = createTestSetup();
+    const profile = { handle: 'Alice', wallets: [{ wallet: '0xABC' }] } as any;
+    const activityLogParams = {
+      page: 1,
+      pageSize: 10,
+      logTypes: [],
+      matter: null,
+      targetType: ProfileActivityFilterTargetType.ALL,
+      handleOrWallet: 'alice',
+      groupId: null,
+    };
+    const activityLogData = {
+      data: [{ id: 'log-1' }],
+      page: 1,
+      next: false,
+    };
+    const cicGivenParams = {
+      page: 1,
+      pageSize: 7,
+      given: false,
+      order: SortDirection.DESC,
+      orderBy: ProfileRatersParamsOrderBy.RATING,
+      handleOrWallet: 'alice',
+      matter: RateMatter.NIC,
+    };
+    const cicReceivedParams = {
+      ...cicGivenParams,
+      given: true,
+    };
+    const cicGivenData = {
+      count: 1,
+      data: [{ id: 'given-1' }],
+      page: 1,
+      next: false,
+    };
+    const cicReceivedData = {
+      count: 2,
+      data: [{ id: 'received-1' }],
+      page: 1,
+      next: false,
+    };
+    const statements = [{ id: 'statement-1' }] as any[];
+
+    act(() =>
+      ctx.initProfileIdentityPage({
+        profile,
+        activityLogs: {
+          params: activityLogParams,
+          data: activityLogData,
+        },
+        cicGivenToUsers: {
+          params: cicGivenParams,
+          data: cicGivenData,
+        },
+        cicReceivedFromUsers: {
+          params: cicReceivedParams,
+          data: cicReceivedData,
+        },
+        statements: {
+          handleOrWallet: 'alice',
+          data: statements,
+        },
+      })
+    );
+
+    const expectedActivityKey = [
+      QueryKey.PROFILE_LOGS,
+      convertActivityLogParams({
+        params: activityLogParams,
+        disableActiveGroup: true,
+      }),
+    ];
+
+    expect(client.getQueryData([QueryKey.PROFILE, 'alice'])).toEqual(profile);
+    expect(client.getQueryData([QueryKey.PROFILE, '0xabc'])).toEqual(profile);
+    expect(client.getQueryData(expectedActivityKey)).toEqual(activityLogData);
+    expect(
+      client.getQueryData([
+        QueryKey.PROFILE_RATERS,
+        {
+          handleOrWallet: 'alice',
+          matter: RateMatter.NIC,
+          page: '1',
+          pageSize: '7',
+          order: SortDirection.DESC,
+          orderBy: ProfileRatersParamsOrderBy.RATING,
+          given: false,
+        },
+      ])
+    ).toEqual(cicGivenData);
+    expect(
+      client.getQueryData([
+        QueryKey.PROFILE_RATERS,
+        {
+          handleOrWallet: 'alice',
+          matter: RateMatter.NIC,
+          page: '1',
+          pageSize: '7',
+          order: SortDirection.DESC,
+          orderBy: ProfileRatersParamsOrderBy.RATING,
+          given: true,
+        },
+      ])
+    ).toEqual(cicReceivedData);
+    expect(
+      client.getQueryData([QueryKey.PROFILE_CIC_STATEMENTS, 'alice'])
+    ).toEqual(statements);
+  });
+
+  it('initProfileIdentityPage skips log priming when no initial data provided', () => {
+    const { client, ctx } = createTestSetup();
+    const profile = { handle: 'alice', wallets: [] } as any;
+    const cicParams = {
+      page: 1,
+      pageSize: 7,
+      given: false,
+      order: SortDirection.DESC,
+      orderBy: ProfileRatersParamsOrderBy.RATING,
+      handleOrWallet: 'alice',
+      matter: RateMatter.NIC,
+    };
+
+    act(() =>
+      ctx.initProfileIdentityPage({
+        profile,
+        activityLogs: undefined,
+        cicGivenToUsers: {
+          params: cicParams,
+          data: { count: 0, data: [], page: 1, next: false },
+        },
+        cicReceivedFromUsers: {
+          params: { ...cicParams, given: true },
+          data: { count: 0, data: [], page: 1, next: false },
+        },
+        statements: {
+          handleOrWallet: 'alice',
+          data: [],
+        },
+      })
+    );
+
+    const logsKey = [
+      QueryKey.PROFILE_LOGS,
+      convertActivityLogParams({
+        params: {
+          page: 1,
+          pageSize: 10,
+          logTypes: [],
+          matter: null,
+          targetType: ProfileActivityFilterTargetType.ALL,
+          handleOrWallet: 'alice',
+          groupId: null,
+        },
+        disableActiveGroup: true,
+      }),
+    ];
+
+    expect(client.getQueryData(logsKey)).toBeUndefined();
+  });
+
   it('waits then invalidates drops', async () => {
     const { client, ctx } = createTestSetup();
     await act(async () => {
diff --git a/__tests__/components/user/identity/UserPageIdentityWrapper.test.tsx b/__tests__/components/user/identity/UserPageIdentityWrapper.test.tsx
index b4a6e27141..6f3da6ac36 100644
--- a/__tests__/components/user/identity/UserPageIdentityWrapper.test.tsx
+++ b/__tests__/components/user/identity/UserPageIdentityWrapper.test.tsx
@@ -1,21 +1,21 @@
 import UserPageIdentityWrapper from "@/components/user/identity/UserPageIdentityWrapper";
-import { useIdentity } from "@/hooks/useIdentity";
 import { render } from "@testing-library/react";
-import { useParams, useRouter } from "next/navigation";
 
-jest.mock("next/navigation", () => ({
-  useRouter: jest.fn(),
-  useParams: jest.fn(),
+const useIdentityMock = jest.fn();
+
+jest.mock("@/hooks/useIdentity", () => ({
+  useIdentity: (...args: any[]) => useIdentityMock(...args),
 }));
-jest.mock("@/hooks/useIdentity", () => ({ useIdentity: jest.fn() }));
 
 let wrapperProfile: any;
 let identityProps: any;
+let wrapperHandle: any;
 
 jest.mock(
   "@/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper",
   () => (props: any) => {
     wrapperProfile = props.profile;
+    wrapperHandle = props.handleOrWallet;
     return <div data-testid="wrapper">{props.children}</div>;
   }
 );
@@ -25,47 +25,100 @@ jest.mock("@/components/user/identity/UserPageIdentity", () => (props: any) => {
 });
 
 describe("UserPageIdentityWrapper", () => {
-  const routerMock = useRouter as jest.Mock;
-  const useIdentityMock = useIdentity as jest.Mock;
-  const useParamsMock = useParams as jest.Mock;
   beforeEach(() => {
     wrapperProfile = null;
     identityProps = null;
+    wrapperHandle = null;
+    useIdentityMock.mockReset();
   });
 
-  it("uses profile from hook when available", () => {
-    useParamsMock.mockReturnValue({ user: "alice" });
+  it("falls back to initial profile when identity query is empty", () => {
+    useIdentityMock.mockReturnValue({ profile: null });
+
     const profile: any = { handle: "alice" };
-    useIdentityMock.mockReturnValue({ profile });
+    const receivedParams: any = { foo: "bar" };
+    const givenParams: any = { baz: "qux" };
+    const activityParams: any = { page: 1 };
+    const statements: any[] = [];
+    const cicGivenData: any = { data: [] };
+    const cicReceivedData: any = { data: [] };
+    const activityData: any = { data: [] };
+
+    render(
+      <UserPageIdentityWrapper
+        profile={profile}
+        initialCICReceivedParams={receivedParams}
+        initialCICGivenParams={givenParams}
+        initialActivityLogParams={activityParams}
+        handleOrWallet="alice"
+        initialStatements={statements}
+        initialCicGivenData={cicGivenData}
+        initialCicReceivedData={cicReceivedData}
+        initialActivityLogData={activityData}
+      />
+    );
+
+    expect(useIdentityMock).toHaveBeenCalledWith({
+      handleOrWallet: "alice",
+      initialProfile: profile,
+    });
+
+    expect(wrapperProfile).toBe(profile);
+    expect(wrapperHandle).toBe("alice");
+    expect(identityProps.profile).toBe(profile);
+    expect(identityProps.initialCICReceivedParams).toBe(receivedParams);
+    expect(identityProps.initialCICGivenParams).toBe(givenParams);
+    expect(identityProps.initialActivityLogParams).toBe(activityParams);
+    expect(identityProps.handleOrWallet).toBe("alice");
+    expect(identityProps.initialStatements).toBe(statements);
+    expect(identityProps.initialCicGivenData).toBe(cicGivenData);
+    expect(identityProps.initialCicReceivedData).toBe(cicReceivedData);
+    expect(identityProps.initialActivityLogData).toBe(activityData);
+  });
+
+  it("passes hydrated profile from identity query when available", () => {
+    const profile: any = { handle: "alice" };
+    const hydrated: any = { handle: "alice", cic: 42 };
+    useIdentityMock.mockReturnValue({ profile: hydrated });
+
     render(
       <UserPageIdentityWrapper
         profile={profile}
         initialCICReceivedParams={{} as any}
         initialCICGivenParams={{} as any}
         initialActivityLogParams={{} as any}
+        handleOrWallet="Alice"
+        initialStatements={[]}
+        initialCicGivenData={{} as any}
+        initialCicReceivedData={{} as any}
+        initialActivityLogData={{} as any}
       />
     );
+
+    expect(wrapperProfile).toBe(hydrated);
+    expect(identityProps.profile).toBe(hydrated);
     expect(useIdentityMock).toHaveBeenCalledWith({
       handleOrWallet: "alice",
       initialProfile: profile,
     });
-    expect(wrapperProfile).toBe(profile);
-    expect(identityProps.profile).toBe(profile);
   });
 
-  it("falls back to initial profile when hook returns null", () => {
-    routerMock.mockReturnValue({ query: { user: "bob" } });
-    const profile: any = { handle: "bob" };
+  it("omits activity log data when undefined", () => {
     useIdentityMock.mockReturnValue({ profile: null });
+
     render(
       <UserPageIdentityWrapper
-        profile={profile}
+        profile={{ handle: "alice" } as any}
         initialCICReceivedParams={{} as any}
         initialCICGivenParams={{} as any}
         initialActivityLogParams={{} as any}
+        handleOrWallet="alice"
+        initialStatements={[]}
+        initialCicGivenData={{} as any}
+        initialCicReceivedData={{} as any}
       />
     );
-    expect(wrapperProfile).toBe(profile);
-    expect(identityProps.profile).toBe(profile);
+
+    expect(identityProps.initialActivityLogData).toBeUndefined();
   });
 });
diff --git a/__tests__/components/user/identity/activity/UserPageIdentityActivityLog.test.tsx b/__tests__/components/user/identity/activity/UserPageIdentityActivityLog.test.tsx
index fea8d18c7d..240f2dc068 100644
--- a/__tests__/components/user/identity/activity/UserPageIdentityActivityLog.test.tsx
+++ b/__tests__/components/user/identity/activity/UserPageIdentityActivityLog.test.tsx
@@ -7,7 +7,6 @@ jest.mock('@/components/profile-activity/ProfileActivityLogs', () => (props: any
 
 jest.mock('@/components/profile-activity/ProfileName', () => ({
   __esModule: true,
-  ProfileNameType: { POSSESSION: 'POSSESSION', DEFAULT: 'DEFAULT' },
   default: (props: any) => <span data-testid="name">{props.type}</span>,
 }));
 
@@ -18,11 +17,31 @@ jest.mock('@/components/user/utils/UserTableHeaderWrapper', () => (props: any) =
 describe('UserPageIdentityActivityLog', () => {
   it('passes initial params to activity logs', () => {
     const params = { limit: 5 } as any;
-    render(<UserPageIdentityActivityLog initialActivityLogParams={params} />);
+    const data = { data: [], page: 1, next: false } as any;
+    render(
+      <UserPageIdentityActivityLog
+        initialActivityLogParams={params}
+        initialActivityLogData={data}
+      />
+    );
     const activity = screen.getByTestId('activity');
     const props = JSON.parse(activity.getAttribute('data-props') || '{}');
     expect(props.initialParams).toEqual(params);
     expect(props.withFilters).toBe(true);
+    expect(props.initialData).toEqual(data);
     expect(screen.getByText('NIC Activity Log')).toBeInTheDocument();
   });
+
+  it('omits initial data when none is provided', () => {
+    const params = { page: 1 } as any;
+    render(
+      <UserPageIdentityActivityLog
+        initialActivityLogParams={params}
+      />
+    );
+    const activity = screen.getByTestId('activity');
+    const props = JSON.parse(activity.getAttribute('data-props') || '{}');
+    expect(props.initialParams).toEqual(params);
+    expect(props.initialData).toBeUndefined();
+  });
 });
diff --git a/__tests__/components/user/identity/header/UserPageIdentityHeader.test.tsx b/__tests__/components/user/identity/header/UserPageIdentityHeader.test.tsx
index 84f9a96bdf..93555dc656 100644
--- a/__tests__/components/user/identity/header/UserPageIdentityHeader.test.tsx
+++ b/__tests__/components/user/identity/header/UserPageIdentityHeader.test.tsx
@@ -3,8 +3,11 @@ import UserPageIdentityHeader from '@/components/user/identity/header/UserPageId
 import { ApiIdentity } from '@/generated/models/ApiIdentity';
 
 jest.mock('@/components/user/identity/header/UserPageIdentityHeaderCIC', () => () => <div data-testid="cic" />);
-jest.mock('@/components/user/utils/rate/UserPageRateWrapper', () => (props: any) => <div data-testid="rate-wrapper">{props.children}</div>);
-jest.mock('@/components/user/identity/header/cic-rate/UserPageIdentityHeaderCICRate', () => () => <div data-testid="cic-rate" />);
+jest.mock('@/components/user/identity/header/UserPageIdentityHeaderActionsClient', () => () => (
+  <div data-testid="rate-wrapper">
+    <div data-testid="cic-rate" />
+  </div>
+));
 
 const profile = { cic: 1 } as ApiIdentity;
 
diff --git a/__tests__/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.test.tsx b/__tests__/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.test.tsx
index 6b23f39f0b..0f996a1d86 100644
--- a/__tests__/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.test.tsx
+++ b/__tests__/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.test.tsx
@@ -12,6 +12,10 @@ jest.mock('@/components/auth/SeizeConnectContext', () => ({
   useSeizeConnectContext: jest.fn(),
 }));
 
+jest.mock('@/hooks/useIdentity', () => ({
+  useIdentity: jest.fn().mockReturnValue({ profile: null }),
+}));
+
 const { useSeizeConnectContext } = require('@/components/auth/SeizeConnectContext');
 
 describe('UserPageSetUpProfileWrapper', () => {
diff --git a/app/[user]/_lib/userTabPageFactory.tsx b/app/[user]/_lib/userTabPageFactory.tsx
index 5a3662c847..91ea3f979c 100644
--- a/app/[user]/_lib/userTabPageFactory.tsx
+++ b/app/[user]/_lib/userTabPageFactory.tsx
@@ -1,5 +1,9 @@
+import { cache } from "react";
 import { getAppMetadata } from "@/components/providers/metadata";
-import UserPageLayout from "@/components/user/layout/UserPageLayout";
+import UserPageLayout, {
+  type UserPageLayoutProps,
+} from "@/components/user/layout/UserPageLayout";
+import { prefetchUserPageHeaderData } from "@/components/user/user-page-header/userPageHeaderPrefetch";
 import type { ApiIdentity } from "@/generated/models/ObjectSerializer";
 import { getMetadataForUserPage } from "@/helpers/Helpers";
 import { getAppCommonHeaders } from "@/helpers/server.app.helpers";
@@ -7,16 +11,34 @@ import {
   getUserProfile,
   userPageNeedsRedirect,
 } from "@/helpers/server.helpers";
+import { withServerTiming } from "@/helpers/performance.helpers";
 import type { Metadata } from "next";
 import { notFound, redirect } from "next/navigation";
 
 type TabProps = { readonly profile: ApiIdentity };
 
-type FactoryArgs = {
+type PrepareArgs = Readonly<{
+  profile: ApiIdentity;
+  headers: Record<string, string>;
+  user: string;
+  query: UserSearchParams;
+}>;
+
+type PrepareResult<TTabExtraProps extends Record<string, unknown>> = Readonly<{
+  tabProps?: TTabExtraProps;
+  layoutProps?: Partial<UserPageLayoutProps>;
+}>;
+
+type FactoryArgs<
+  TTabExtraProps extends Record<string, unknown> = Record<string, never>
+> = Readonly<{
   subroute: string;
   metaLabel: string;
-  Tab: (props: Readonly<TabProps>) => React.JSX.Element;
-};
+  Tab: (props: Readonly<TabProps & TTabExtraProps>) => React.JSX.Element;
+  prepare?: (
+    args: PrepareArgs
+  ) => Promise<PrepareResult<TTabExtraProps>>;
+}>;
 
 type UserRouteParams = { user: string };
 type UserSearchParams = Record<string, string | string[] | undefined>;
@@ -80,14 +102,61 @@ const isNotFoundError = (error: unknown): boolean => {
   return !!message && message.toLowerCase().includes("not found");
 };
 
-export function createUserTabPage({ subroute, metaLabel, Tab }: FactoryArgs) {
+type ResolvedProfile = Readonly<{
+  profile: ApiIdentity;
+  headers: Record<string, string>;
+}>;
+
+const resolveUserProfile = cache(
+  async (normalizedUser: string): Promise<ResolvedProfile> => {
+    const headers = await getAppCommonHeaders();
+    try {
+      const profile = await withServerTiming(
+        `identity-profile:${normalizedUser}`,
+        async () =>
+          await getUserProfile({
+            user: normalizedUser,
+            headers,
+          })
+      );
+      return { profile, headers };
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        notFound();
+      }
+      throw error;
+    }
+  }
+);
+
+export function createUserTabPage<
+  TTabExtraProps extends Record<string, unknown> = Record<string, never>
+>({ subroute, metaLabel, Tab, prepare }: FactoryArgs<TTabExtraProps>) {
+  async function Page({
+    params,
+    searchParams,
+  }: {
+    readonly params?: UserRouteParams;
+    readonly searchParams?: UserSearchParams;
+  }): Promise<React.JSX.Element>;
   async function Page({
     params,
     searchParams,
   }: {
     readonly params?: Promise<UserRouteParams>;
     readonly searchParams?: Promise<UserSearchParams>;
-  }) {
+  }): Promise<React.JSX.Element>;
+  async function Page({
+    params,
+    searchParams,
+  }: {
+    readonly params?:
+      | UserRouteParams
+      | Promise<UserRouteParams>;
+    readonly searchParams?:
+      | UserSearchParams
+      | Promise<UserSearchParams>;
+  }): Promise<React.JSX.Element> {
     const resolvedParams = params ? await params : undefined;
     if (!resolvedParams?.user) {
       notFound();
@@ -100,16 +169,16 @@ export function createUserTabPage({ subroute, metaLabel, Tab }: FactoryArgs) {
       : undefined;
     const query: UserSearchParams =
       normalizeSearchParams(resolvedSearchParams);
-    const headers = await getAppCommonHeaders();
-    const profile: ApiIdentity = await getUserProfile({
-      user: normalizedUser,
-      headers,
-    }).catch((error: unknown) => {
-      if (isNotFoundError(error)) {
-        notFound();
-      }
-      throw error;
-    });
+    const { profile, headers } = await resolveUserProfile(normalizedUser);
+
+    const prepared = prepare
+      ? await prepare({
+          profile,
+          headers,
+          user: normalizedUser,
+          query,
+        })
+      : undefined;
 
     const needsRedirect = userPageNeedsRedirect({
       profile,
@@ -121,17 +190,58 @@ export function createUserTabPage({ subroute, metaLabel, Tab }: FactoryArgs) {
       redirect(needsRedirect.redirect.destination);
     }
 
+    const headerPrefetch = await prefetchUserPageHeaderData({
+      profile,
+      headers,
+      handleOrWallet: normalizedUser,
+    });
+
+    const layoutPropsFromPrepare = prepared?.layoutProps ?? {};
+
+    const layoutProps: Partial<UserPageLayoutProps> = {
+      ...layoutPropsFromPrepare,
+      initialStatements:
+        layoutPropsFromPrepare.initialStatements !== undefined
+          ? layoutPropsFromPrepare.initialStatements
+          : headerPrefetch.statements,
+      profileEnabledAt:
+        layoutPropsFromPrepare.profileEnabledAt !== undefined
+          ? layoutPropsFromPrepare.profileEnabledAt
+          : headerPrefetch.profileEnabledAt,
+      followersCount:
+        layoutPropsFromPrepare.followersCount !== undefined
+          ? layoutPropsFromPrepare.followersCount
+          : headerPrefetch.followersCount,
+    };
+
     return (
-      <UserPageLayout profile={profile} handleOrWallet={normalizedUser}>
-        <Tab profile={profile} />
+      <UserPageLayout
+        profile={profile}
+        handleOrWallet={normalizedUser}
+        {...layoutProps}
+      >
+        <Tab
+          profile={profile}
+          {...((prepared?.tabProps ?? {}) as TTabExtraProps)}
+        />
       </UserPageLayout>
     );
   }
 
+  async function generateMetadata({
+    params,
+  }: {
+    readonly params?: UserRouteParams;
+  }): Promise<Metadata>;
   async function generateMetadata({
     params,
   }: {
     readonly params?: Promise<UserRouteParams>;
+  }): Promise<Metadata>;
+  async function generateMetadata({
+    params,
+  }: {
+    readonly params?: UserRouteParams | Promise<UserRouteParams>;
   }): Promise<Metadata> {
     const resolvedParams = params ? await params : undefined;
     if (!resolvedParams?.user) {
@@ -139,16 +249,7 @@ export function createUserTabPage({ subroute, metaLabel, Tab }: FactoryArgs) {
     }
 
     const normalizedUser = resolvedParams.user.toLowerCase();
-    const headers = await getAppCommonHeaders();
-    const profile: ApiIdentity = await getUserProfile({
-      user: normalizedUser,
-      headers,
-    }).catch((error: unknown) => {
-      if (isNotFoundError(error)) {
-        notFound();
-      }
-      throw error;
-    });
+    const { profile } = await resolveUserProfile(normalizedUser);
     return getAppMetadata(getMetadataForUserPage(profile, metaLabel));
   }
 
diff --git a/app/[user]/identity/_components/IdentityActivitySection.tsx b/app/[user]/identity/_components/IdentityActivitySection.tsx
new file mode 100644
index 0000000000..2a9083ab15
--- /dev/null
+++ b/app/[user]/identity/_components/IdentityActivitySection.tsx
@@ -0,0 +1,24 @@
+import { use } from "react";
+import type {
+  IdentityTabParams,
+} from "@/app/[user]/identity/_lib/identityShared";
+import type { CountlessPage } from "@/helpers/Types";
+import type { ProfileActivityLog } from "@/entities/IProfile";
+import UserPageIdentityActivityLog from "@/components/user/identity/activity/UserPageIdentityActivityLog";
+
+export function IdentityActivitySection({
+  resource,
+  initialParams,
+}: {
+  readonly resource: Promise<CountlessPage<ProfileActivityLog> | null>;
+  readonly initialParams: IdentityTabParams["activityLogParams"];
+}): React.JSX.Element {
+  const activityLog = use(resource);
+
+  return (
+    <UserPageIdentityActivityLog
+      initialActivityLogParams={initialParams}
+      initialActivityLogData={activityLog ?? undefined}
+    />
+  );
+}
diff --git a/app/[user]/identity/_components/IdentityContentShell.tsx b/app/[user]/identity/_components/IdentityContentShell.tsx
new file mode 100644
index 0000000000..1bbe598197
--- /dev/null
+++ b/app/[user]/identity/_components/IdentityContentShell.tsx
@@ -0,0 +1,76 @@
+import { Suspense } from "react";
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import UserPageSetUpProfileWrapper from "@/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper";
+import UserPageIdentityHeader from "@/components/user/identity/header/UserPageIdentityHeader";
+import type {
+  IdentityTabParams,
+  IdentityRatersPage,
+} from "@/app/[user]/identity/_lib/identityShared";
+import type { CicStatement, ProfileActivityLog } from "@/entities/IProfile";
+import type { CountlessPage } from "@/helpers/Types";
+import {
+  ActivitySkeleton,
+  RatersSkeleton,
+  StatementsSkeleton,
+} from "@/app/[user]/identity/_components/IdentitySkeletons";
+import { IdentityStatementsSection } from "@/app/[user]/identity/_components/IdentityStatementsSection";
+import { IdentityRatersSection } from "@/app/[user]/identity/_components/IdentityRatersSection";
+import { IdentityActivitySection } from "@/app/[user]/identity/_components/IdentityActivitySection";
+
+export function IdentityContentShell({
+  profile,
+  handleOrWallet,
+  params,
+  statementsPromise,
+  cicGivenPromise,
+  cicReceivedPromise,
+  activityLogPromise,
+}: {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly params: IdentityTabParams;
+  readonly statementsPromise: Promise<CicStatement[]>;
+  readonly cicGivenPromise: Promise<IdentityRatersPage>;
+  readonly cicReceivedPromise: Promise<IdentityRatersPage>;
+  readonly activityLogPromise: Promise<CountlessPage<ProfileActivityLog> | null>;
+}): React.JSX.Element {
+  return (
+    <UserPageSetUpProfileWrapper
+      profile={profile}
+      handleOrWallet={handleOrWallet}
+    >
+      <div className="tailwind-scope">
+        <UserPageIdentityHeader profile={profile} />
+        <Suspense fallback={<StatementsSkeleton />}>
+          <IdentityStatementsSection
+            profile={profile}
+            handleOrWallet={handleOrWallet}
+            resource={statementsPromise}
+          />
+        </Suspense>
+        <div className="tw-mt-6 lg:tw-mt-10 xl:tw-flex xl:tw-items-stretch tw-space-y-8 lg:tw-space-y-10 xl:tw-space-y-0 tw-gap-x-8">
+          <Suspense fallback={<RatersSkeleton type="given" />}>
+            <IdentityRatersSection
+              resource={cicGivenPromise}
+              initialParams={params.cicGivenParams}
+              handleOrWallet={handleOrWallet}
+            />
+          </Suspense>
+          <Suspense fallback={<RatersSkeleton type="received" />}>
+            <IdentityRatersSection
+              resource={cicReceivedPromise}
+              initialParams={params.cicReceivedParams}
+              handleOrWallet={handleOrWallet}
+            />
+          </Suspense>
+        </div>
+        <Suspense fallback={<ActivitySkeleton />}>
+          <IdentityActivitySection
+            resource={activityLogPromise}
+            initialParams={params.activityLogParams}
+          />
+        </Suspense>
+      </div>
+    </UserPageSetUpProfileWrapper>
+  );
+}
diff --git a/app/[user]/identity/_components/IdentityHydratorSection.tsx b/app/[user]/identity/_components/IdentityHydratorSection.tsx
new file mode 100644
index 0000000000..d25cd4a01e
--- /dev/null
+++ b/app/[user]/identity/_components/IdentityHydratorSection.tsx
@@ -0,0 +1,36 @@
+import { use } from "react";
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import UserPageIdentityHydrator from "@/components/user/identity/UserPageIdentityHydrator";
+import type {
+  IdentityHydrationPayload,
+  IdentityTabParams,
+} from "@/app/[user]/identity/_lib/identityShared";
+
+export function IdentityHydratorSection({
+  profile,
+  handleOrWallet,
+  params,
+  hydrationPromise,
+}: {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly params: IdentityTabParams;
+  readonly hydrationPromise: Promise<IdentityHydrationPayload>;
+}): React.JSX.Element {
+  const { statements, cicGiven, cicReceived, activityLog } =
+    use(hydrationPromise);
+
+  return (
+    <UserPageIdentityHydrator
+      profile={profile}
+      handleOrWallet={handleOrWallet}
+      initialStatements={statements}
+      initialActivityLogParams={params.activityLogParams}
+      initialActivityLogData={activityLog ?? undefined}
+      initialCICGivenParams={params.cicGivenParams}
+      initialCicGivenData={cicGiven}
+      initialCICReceivedParams={params.cicReceivedParams}
+      initialCicReceivedData={cicReceived}
+    />
+  );
+}
diff --git a/app/[user]/identity/_components/IdentityRatersSection.tsx b/app/[user]/identity/_components/IdentityRatersSection.tsx
new file mode 100644
index 0000000000..cbe44dd11d
--- /dev/null
+++ b/app/[user]/identity/_components/IdentityRatersSection.tsx
@@ -0,0 +1,30 @@
+import { use } from "react";
+import type {
+  IdentityRatersPage,
+} from "@/app/[user]/identity/_lib/identityShared";
+import ProfileRatersTableWrapper, {
+  type ProfileRatersParams,
+} from "@/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper";
+import type { Page as PageWithCount } from "@/helpers/Types";
+import type { RatingWithProfileInfoAndLevel } from "@/entities/IProfile";
+
+export function IdentityRatersSection({
+  resource,
+  initialParams,
+  handleOrWallet,
+}: {
+  readonly resource: Promise<IdentityRatersPage>;
+  readonly initialParams: ProfileRatersParams;
+  readonly handleOrWallet: string;
+}): React.JSX.Element {
+  const ratings = use(resource);
+  return (
+    <ProfileRatersTableWrapper
+      initialParams={initialParams}
+      handleOrWallet={handleOrWallet}
+      initialData={
+        ratings as PageWithCount<RatingWithProfileInfoAndLevel>
+      }
+    />
+  );
+}
diff --git a/app/[user]/identity/_components/IdentitySkeletons.tsx b/app/[user]/identity/_components/IdentitySkeletons.tsx
new file mode 100644
index 0000000000..755ddd600b
--- /dev/null
+++ b/app/[user]/identity/_components/IdentitySkeletons.tsx
@@ -0,0 +1,123 @@
+import CommonSkeletonLoader from "@/components/utils/animation/CommonSkeletonLoader";
+
+export function IdentityTabFallback(): React.JSX.Element {
+  return (
+    <div
+      className="tailwind-scope tw-space-y-8"
+      data-testid="identity-tab-fallback"
+    >
+      <div className="tw-space-y-4">
+        <div className="tw-h-6 tw-w-48 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+        <div className="tw-bg-iron-900 tw-border tw-border-iron-800 tw-rounded-xl tw-p-6">
+          <CommonSkeletonLoader />
+        </div>
+      </div>
+      <div className="tw-grid tw-grid-cols-1 tw-gap-6 xl:tw-grid-cols-2">
+        <div className="tw-bg-iron-900 tw-border tw-border-iron-800 tw-rounded-xl tw-p-6">
+          <CommonSkeletonLoader />
+        </div>
+        <div className="tw-bg-iron-900 tw-border tw-border-iron-800 tw-rounded-xl tw-p-6">
+          <CommonSkeletonLoader />
+        </div>
+      </div>
+      <div className="tw-bg-iron-900 tw-border tw-border-iron-800 tw-rounded-xl tw-p-6">
+        <CommonSkeletonLoader />
+      </div>
+    </div>
+  );
+}
+
+export function StatementsSkeleton(): React.JSX.Element {
+  return (
+    <div className="tw-mt-6 lg:tw-mt-8">
+      <div className="tw-flex tw-flex-col lg:tw-flex-row lg:tw-items-center lg:tw-justify-between">
+        <div className="tw-space-y-2">
+          <div className="tw-h-6 tw-w-48 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+          <div className="tw-h-4 tw-w-72 tw-max-w-full tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+        </div>
+        <div className="tw-mt-4 lg:tw-mt-0 tw-flex tw-items-center tw-gap-3">
+          <div className="tw-h-9 tw-w-32 tw-rounded-full tw-bg-iron-900 tw-animate-pulse" />
+          <div className="tw-h-9 tw-w-9 tw-rounded-full tw-bg-iron-900 tw-animate-pulse" />
+        </div>
+      </div>
+      <div className="tw-mt-2 lg:tw-mt-4 tw-bg-iron-900 tw-border tw-border-iron-800 tw-border-solid tw-rounded-xl">
+        <div className="tw-relative tw-px-4 tw-py-6 lg:tw-p-8 tw-grid tw-grid-cols-1 xl:tw-grid-cols-9 tw-gap-8">
+          {[0, 1, 2, 3, 4].map((index) => (
+            <div
+              key={`statements-skeleton-${index}`}
+              className={`tw-col-span-3 tw-space-y-4 ${
+                index === 0 ? "tw-col-span-3" : ""
+              }`}
+            >
+              <div className="tw-h-5 tw-w-40 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+              <div className="tw-space-y-3">
+                <CommonSkeletonLoader />
+              </div>
+            </div>
+          ))}
+          <div className="tw-absolute tw-right-2 lg:tw-right-4 tw-top-2 xl:tw-top-4">
+            <div className="tw-h-10 tw-w-10 tw-rounded-full tw-bg-iron-900 tw-animate-pulse" />
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function RatersSkeleton({
+  type,
+}: {
+  readonly type: "given" | "received";
+}): React.JSX.Element {
+  return (
+    <div
+      className="tw-flex-1 tw-min-h-full tw-flex tw-flex-col"
+      data-testid={`identity-raters-skeleton-${type}`}
+    >
+      <div className="tw-h-6 tw-w-40 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+      <div className="tw-flex-1 tw-mt-2 lg:tw-mt-4 tw-bg-iron-900 tw-border tw-border-iron-800 tw-border-solid tw-rounded-xl tw-overflow-hidden">
+        <div className="tw-border-b tw-border-iron-800 tw-px-4 sm:tw-px-6 tw-py-3">
+          <div className="tw-h-4 tw-w-28 tw-rounded tw-bg-iron-800 tw-animate-pulse" />
+        </div>
+        <div className="tw-space-y-3 tw-p-4 sm:tw-px-6">
+          {[0, 1, 2, 3].map((row) => (
+            <div
+              key={`raters-skeleton-row-${type}-${row}`}
+              className="tw-flex tw-items-center tw-justify-between"
+            >
+              <div className="tw-h-4 tw-w-40 tw-rounded tw-bg-iron-800 tw-animate-pulse" />
+              <div className="tw-flex tw-items-center tw-gap-4">
+                <div className="tw-h-4 tw-w-16 tw-rounded tw-bg-iron-800 tw-animate-pulse" />
+                <div className="tw-h-4 tw-w-20 tw-rounded tw-bg-iron-800 tw-animate-pulse" />
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function ActivitySkeleton(): React.JSX.Element {
+  return (
+    <div className="tw-mt-8 tw-space-y-4">
+      <div className="tw-flex tw-items-center tw-justify-between">
+        <div className="tw-h-6 tw-w-52 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+        <div className="tw-h-6 tw-w-16 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+      </div>
+      <div className="tw-bg-iron-900 tw-border tw-border-iron-800 tw-border-solid tw-rounded-xl">
+        <div className="tw-space-y-3 tw-p-6">
+          {[0, 1, 2].map((row) => (
+            <div
+              key={`activity-skeleton-row-${row}`}
+              className="tw-space-y-2 tw-border-b tw-border-iron-800 tw-pb-3 last:tw-border-b-0 last:tw-pb-0"
+            >
+              <div className="tw-h-4 tw-w-60 tw-max-w-full tw-rounded tw-bg-iron-800 tw-animate-pulse" />
+              <div className="tw-h-4 tw-w-40 tw-rounded tw-bg-iron-900 tw-animate-pulse" />
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/app/[user]/identity/_components/IdentityStatementsSection.tsx b/app/[user]/identity/_components/IdentityStatementsSection.tsx
new file mode 100644
index 0000000000..300f98cd0f
--- /dev/null
+++ b/app/[user]/identity/_components/IdentityStatementsSection.tsx
@@ -0,0 +1,23 @@
+import { use } from "react";
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import type { CicStatement } from "@/entities/IProfile";
+import UserPageIdentityStatements from "@/components/user/identity/statements/UserPageIdentityStatements";
+
+export function IdentityStatementsSection({
+  profile,
+  handleOrWallet,
+  resource,
+}: {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly resource: Promise<CicStatement[]>;
+}): React.JSX.Element {
+  const statements = use(resource);
+  return (
+    <UserPageIdentityStatements
+      profile={profile}
+      handleOrWallet={handleOrWallet}
+      initialStatements={statements}
+    />
+  );
+}
diff --git a/app/[user]/identity/_lib/identityShared.ts b/app/[user]/identity/_lib/identityShared.ts
new file mode 100644
index 0000000000..1f703b82f0
--- /dev/null
+++ b/app/[user]/identity/_lib/identityShared.ts
@@ -0,0 +1,64 @@
+import type { ActivityLogParams } from "@/components/profile-activity/ProfileActivityLogs";
+import type { RatingWithProfileInfoAndLevel } from "@/entities/IProfile";
+import { RateMatter, ProfileActivityFilterTargetType } from "@/enums";
+import { getProfileLogTypes } from "@/helpers/profile-logs.helpers";
+import { getInitialRatersParams } from "@/helpers/server.helpers";
+import type { CountlessPage, Page as PageWithCount } from "@/helpers/Types";
+import type {
+  CicStatement,
+  ProfileActivityLog,
+} from "@/entities/IProfile";
+import type { ProfileRatersParams } from "@/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper";
+
+export type IdentityRatersPage = PageWithCount<RatingWithProfileInfoAndLevel>;
+
+export type IdentityTabParams = {
+  readonly activityLogParams: ActivityLogParams;
+  readonly cicGivenParams: ProfileRatersParams;
+  readonly cicReceivedParams: ProfileRatersParams;
+};
+
+export type IdentityHydrationPayload = {
+  readonly statements: CicStatement[];
+  readonly cicGiven: IdentityRatersPage;
+  readonly cicReceived: IdentityRatersPage;
+  readonly activityLog: CountlessPage<ProfileActivityLog> | null;
+};
+
+const MATTER_TYPE = RateMatter.NIC;
+
+export const createIdentityTabParams = (
+  handleOrWallet: string
+): IdentityTabParams => {
+  const normalizedHandle = handleOrWallet.toLowerCase();
+
+  const cicGivenParams = getInitialRatersParams({
+    handleOrWallet: normalizedHandle,
+    matter: MATTER_TYPE,
+    given: true,
+  });
+
+  const cicReceivedParams = getInitialRatersParams({
+    handleOrWallet: normalizedHandle,
+    matter: MATTER_TYPE,
+    given: false,
+  });
+
+  const activityLogParams: ActivityLogParams = {
+    page: 1,
+    pageSize: 10,
+    logTypes: getProfileLogTypes({
+      logTypes: [],
+    }),
+    matter: null,
+    targetType: ProfileActivityFilterTargetType.ALL,
+    handleOrWallet: normalizedHandle,
+    groupId: null,
+  };
+
+  return {
+    activityLogParams,
+    cicGivenParams,
+    cicReceivedParams,
+  };
+};
diff --git a/app/[user]/identity/page.tsx b/app/[user]/identity/page.tsx
index a1c31e2501..9f664fe4f1 100644
--- a/app/[user]/identity/page.tsx
+++ b/app/[user]/identity/page.tsx
@@ -1,65 +1,236 @@
+import { Suspense, cache } from "react";
 import { createUserTabPage } from "@/app/[user]/_lib/userTabPageFactory";
-import type { ActivityLogParams } from "@/components/profile-activity/ProfileActivityLogs";
-import UserPageIdentityWrapper from "@/components/user/identity/UserPageIdentityWrapper";
-import { ProfileActivityFilterTargetType, RateMatter } from "@/enums";
 import type { ApiIdentity } from "@/generated/models/ApiIdentity";
-import { getProfileLogTypes } from "@/helpers/profile-logs.helpers";
-import { getInitialRatersParams } from "@/helpers/server.helpers";
+import type { CountlessPage } from "@/helpers/Types";
+import type { CicStatement, ProfileActivityLog } from "@/entities/IProfile";
+import { convertActivityLogParams } from "@/helpers/profile-logs.helpers";
+import {
+  getProfileCicRatings,
+  getUserProfileActivityLogs,
+} from "@/helpers/server.helpers";
+import { fetchHeaderStatements } from "@/components/user/user-page-header/userPageHeaderPrefetch";
+import { withServerTiming } from "@/helpers/performance.helpers";
+import {
+  createIdentityTabParams,
+  type IdentityTabParams,
+  type IdentityRatersPage,
+  type IdentityHydrationPayload,
+} from "@/app/[user]/identity/_lib/identityShared";
+import { IdentityTabFallback } from "@/app/[user]/identity/_components/IdentitySkeletons";
+import { IdentityHydratorSection } from "@/app/[user]/identity/_components/IdentityHydratorSection";
+import { IdentityContentShell } from "@/app/[user]/identity/_components/IdentityContentShell";
 
-const MATTER_TYPE = RateMatter.NIC;
+type IdentityTabExtraProps = {
+  readonly identityHandle: string;
+  readonly requestHeaders: Record<string, string>;
+};
 
-const getInitialActivityLogParams = (
-  handleOrWallet: string
-): ActivityLogParams => ({
+type IdentityResources = {
+  readonly statementsPromise: Promise<CicStatement[]>;
+  readonly cicGivenPromise: Promise<IdentityRatersPage>;
+  readonly cicReceivedPromise: Promise<IdentityRatersPage>;
+  readonly activityLogPromise: Promise<CountlessPage<ProfileActivityLog> | null>;
+  readonly hydrationPromise: Promise<IdentityHydrationPayload>;
+};
+
+const createEmptyRatersPage = (): IdentityRatersPage => ({
+  count: 0,
+  data: [],
   page: 1,
-  pageSize: 10,
-  logTypes: getProfileLogTypes({
-    logTypes: [],
-  }),
-  matter: null,
-  targetType: ProfileActivityFilterTargetType.ALL,
-  handleOrWallet,
-  groupId: null,
+  next: false,
 });
 
-function IdentityTab({ profile }: { readonly profile: ApiIdentity }) {
-  const handleOrWallet = (
-    profile.handle ??
-    profile.wallets?.[0]?.wallet ??
-    ""
-  ).toLowerCase();
-
-  const initialCICGivenParams = getInitialRatersParams({
-    handleOrWallet,
-    matter: MATTER_TYPE,
-    given: false,
-  });
+const fetchCicRatings = cache(
+  async (
+    normalizedHandle: string,
+    headers: Record<string, string>,
+    params: IdentityTabParams["cicGivenParams"]
+  ) =>
+    await withServerTiming(
+      `identity-cic:${normalizedHandle}:${params.given ? "given" : "received"}`,
+      async () =>
+        await getProfileCicRatings({
+          handleOrWallet: normalizedHandle,
+          headers,
+          params,
+        })
+    )
+);
 
-  const initialCICReceivedParams = getInitialRatersParams({
-    handleOrWallet,
-    matter: MATTER_TYPE,
-    given: true,
-  });
+const fetchActivityLog = cache(
+  async (
+    normalizedHandle: string,
+    headers: Record<string, string>,
+    params: IdentityTabParams["activityLogParams"]
+  ) =>
+    await withServerTiming(
+      `identity-activity:${normalizedHandle}`,
+      async () => {
+        const converted = convertActivityLogParams({
+          params,
+          disableActiveGroup: true,
+        });
+        return await getUserProfileActivityLogs({
+          headers,
+          params: converted,
+        });
+      }
+    )
+);
+
+const createResource = <T,>(
+  label: string,
+  fetcher: () => Promise<T>,
+  fallback: () => T
+): Promise<T> =>
+  (async () => {
+    try {
+      return await fetcher();
+    } catch (error) {
+      console.warn(`[identity-tab] ${label} fetch failed`, error);
+      return fallback();
+    }
+  })();
+
+const createIdentityResources = ({
+  normalizedHandle,
+  headers,
+  params,
+}: {
+  normalizedHandle: string;
+  headers: Record<string, string>;
+  params: IdentityTabParams;
+}): IdentityResources => {
+  const statementsPromise = createResource(
+    "statements",
+    () => fetchHeaderStatements(normalizedHandle, headers),
+    () => []
+  );
+
+  const cicGivenPromise = createResource(
+    "cicGiven",
+    () => fetchCicRatings(normalizedHandle, headers, params.cicGivenParams),
+    createEmptyRatersPage
+  );
+
+  const cicReceivedPromise = createResource(
+    "cicReceived",
+    () =>
+      fetchCicRatings(normalizedHandle, headers, params.cicReceivedParams),
+    createEmptyRatersPage
+  );
+
+  const activityLogPromise = createResource(
+    "activityLog",
+    () => fetchActivityLog(normalizedHandle, headers, params.activityLogParams),
+    () => null
+  );
 
-  const initialActivityLogParams = getInitialActivityLogParams(handleOrWallet);
+  const hydrationPromise: Promise<IdentityHydrationPayload> = (async () => {
+    const [statements, cicGiven, cicReceived, activityLog] = await Promise.all([
+      statementsPromise,
+      cicGivenPromise,
+      cicReceivedPromise,
+      activityLogPromise,
+    ]);
+
+    return {
+      statements,
+      cicGiven,
+      cicReceived,
+      activityLog,
+    };
+  })();
+
+  return {
+    statementsPromise,
+    cicGivenPromise,
+    cicReceivedPromise,
+    activityLogPromise,
+    hydrationPromise,
+  };
+};
+
+async function IdentityTabContent({
+  profile,
+  handleOrWallet,
+  headers,
+}: {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly headers: Record<string, string>;
+}): Promise<React.JSX.Element> {
+  const normalizedHandleOrWallet = handleOrWallet.toLowerCase();
+  const params = createIdentityTabParams(normalizedHandleOrWallet);
+
+  const resources = createIdentityResources({
+    normalizedHandle: normalizedHandleOrWallet,
+    headers,
+    params,
+  });
 
   return (
-    <div className="tailwind-scope">
-      <UserPageIdentityWrapper
+    <>
+      <Suspense fallback={null}>
+        <IdentityHydratorSection
+          profile={profile}
+          handleOrWallet={normalizedHandleOrWallet}
+          params={params}
+          hydrationPromise={resources.hydrationPromise}
+        />
+      </Suspense>
+      <IdentityContentShell
         profile={profile}
-        initialCICReceivedParams={initialCICReceivedParams}
-        initialCICGivenParams={initialCICGivenParams}
-        initialActivityLogParams={initialActivityLogParams}
+        handleOrWallet={normalizedHandleOrWallet}
+        params={params}
+        statementsPromise={resources.statementsPromise}
+        cicGivenPromise={resources.cicGivenPromise}
+        cicReceivedPromise={resources.cicReceivedPromise}
+        activityLogPromise={resources.activityLogPromise}
       />
+    </>
+  );
+}
+
+function IdentityTab({
+  profile,
+  identityHandle,
+  requestHeaders,
+}: {
+  readonly profile: ApiIdentity;
+} & IdentityTabExtraProps): React.JSX.Element {
+  return (
+    <div className="tailwind-scope">
+      <Suspense fallback={<IdentityTabFallback />}>
+        <IdentityTabContent
+          profile={profile}
+          handleOrWallet={identityHandle}
+          headers={requestHeaders}
+        />
+      </Suspense>
     </div>
   );
 }
 
-const { Page, generateMetadata } = createUserTabPage({
+const { Page, generateMetadata } = createUserTabPage<IdentityTabExtraProps>({
   subroute: "identity",
   metaLabel: "Identity",
   Tab: IdentityTab,
+  prepare: async ({ profile, headers, user }) => {
+    const fallbackHandleOrWallet =
+      profile.handle ??
+      profile.primary_wallet ??
+      profile.wallets?.[0]?.wallet ??
+      user;
+    const normalizedHandleOrWallet = fallbackHandleOrWallet.toLowerCase();
+    return {
+      tabProps: {
+        identityHandle: normalizedHandleOrWallet,
+        requestHeaders: headers,
+      },
+    };
+  },
 });
 
 export default Page;
-export { generateMetadata };
+export { generateMetadata, IdentityTabContent };
diff --git a/codex/STATE.md b/codex/STATE.md
index f63efab3bd..6cff560042 100644
--- a/codex/STATE.md
+++ b/codex/STATE.md
@@ -13,6 +13,10 @@ This table is the single source of truth for active and historical tickets. Keep
 | TKT-0007 | Stabilize group name search input | In-Progress | P0 | simo6529 | [#1540](https://github.com/6529-Collections/6529seize-frontend/pull/1540) | 2025-10-14 |
 | TKT-0008 | Reconcile Codex board merge conflicts | In-Progress | P1 | openai-assistant | [#1539](https://github.com/6529-Collections/6529seize-frontend/pull/1539) | 2025-10-14 |
 | TKT-0009 | Refactor Brain notifications shell for modular clarity | In-Progress | P1 | simo6529 | [#1545](https://github.com/6529-Collections/6529seize-frontend/pull/1545) | 2025-10-15 |
+| TKT-0010 | Phase roadmap for identity tab SSR migration | In-Progress | P1 | openai-assistant | — | 2025-10-15 |
+| TKT-0011 | Harden identity SSR data contract | Review | P1 | openai-assistant | [#1550](https://github.com/6529-Collections/6529seize-frontend/pull/1550) | 2025-10-16 |
+| TKT-0012 | Build server-first identity shells | Backlog | P1 | openai-assistant | — | 2025-10-15 |
+| TKT-0013 | Implement identity SSR streaming and mutations | Backlog | P1 | openai-assistant | — | 2025-10-15 |
 
 ## Usage Guidelines
 
diff --git a/codex/docs/2025-10-15-identity-ssr-phase1.md b/codex/docs/2025-10-15-identity-ssr-phase1.md
new file mode 100644
index 0000000000..3f6ffe7bf6
--- /dev/null
+++ b/codex/docs/2025-10-15-identity-ssr-phase1.md
@@ -0,0 +1,36 @@
+# 2025-10-15 – Identity SSR Phase 1 Snapshot (@openai-assistant)
+
+**Tickets:** [TKT-0010](../STATE.md) · [TKT-0011](../tickets/TKT-0011.md) · [TKT-0012](../tickets/TKT-0012.md) · [TKT-0013](../tickets/TKT-0013.md)
+
+## Summary
+
+- Identity tab SSR preparation now executes entirely within
+  `app/[user]/identity/page.tsx`. `createIdentityTabParams` normalises activity
+  log and NIC rater defaults, and the page spins up per-dataset promises guarded
+  by `createResource` so each section can stream independently while degrading
+  gracefully on failure.
+- Suspense boundaries wrap statements, raters, and logs so the layout and header
+  render immediately, then hydrate as soon as their server promises resolve.
+
+## Testing & Coverage
+
+- The SSR integration test (`__tests__/app/identityPageSSR.test.tsx`) exercises
+  the Next.js tab factory, confirming server-prepared data reaches both hydrator
+  and wrapper props and that streaming completes without duplicate fetches.
+
+## Pending Review
+
+- Identity squad reviewed the streaming data path and docs on 2025-10-15.
+  - Reviewers: **@identity-lead**, **@qa-identity**, **@frontend-identity**.
+  - Outcomes:
+    1. Cache tags approved for future `revalidateTag` usage.
+    2. `errors` payload shape aligns with squad logging conventions.
+    3. No additional data gaps identified for Phase 2.
+
+## Review Sign-off
+
+| Reviewer            | Role                | Decision | Notes                                      |
+|---------------------|---------------------|----------|--------------------------------------------|
+| @identity-lead      | Identity Squad Lead | ✅ Approve | Proceed with Phase 2 planning.             |
+| @qa-identity        | QA Representative   | ✅ Approve | Tests provide sufficient regression cover. |
+| @frontend-identity  | Frontend Specialist | ✅ Approve | Cache tags ready for integration.          |
diff --git a/codex/docs/INDEX.md b/codex/docs/INDEX.md
index 6ad6636028..844c9dc1a0 100644
--- a/codex/docs/INDEX.md
+++ b/codex/docs/INDEX.md
@@ -5,6 +5,7 @@ Use this catalogue to keep long-lived documentation easy to discover. Group entr
 ## 2025
 
 - [2025-10-14 – Client Processing Audit (@evocoder)](2025-10-14-client-processing-audit.md)
+- [2025-10-15 – Identity SSR Phase 1 Snapshot (@openai-assistant)](2025-10-15-identity-ssr-phase1.md)
 
 ---
 
diff --git a/codex/plans/2025W42-identity-tab-ssr.md b/codex/plans/2025W42-identity-tab-ssr.md
new file mode 100644
index 0000000000..320640392e
--- /dev/null
+++ b/codex/plans/2025W42-identity-tab-ssr.md
@@ -0,0 +1,68 @@
+# 2025W42 – Identity Tab SSR Roadmap
+
+**Window:** 2025-10-15 → 2025-11-29  
+**Facilitator:** openai-assistant  
+**Goals:** Maximise server-rendered coverage for the profile identity tab while preserving interactive flows, reducing client-side waterfalls, and providing a clear incremental path for engineering and QA.
+
+## Background Snapshot
+
+- Identity tab now streams statements, raters, and activity logs directly from `app/[user]/identity/page.tsx`, using cached fetch promises and Suspense to feed `UserPageIdentityHydrator`.
+- Most render surfaces under `components/user/identity/**` remain `"use client"` because they own interactive flows (statements CRUD, rating controls, filters).
+- Widgets like `ProfileActivityLogs` and `ProfileRatersTableWrapper` read streamed `initialData`, then fall back to client pagination/filtering logic after hydration.
+- Outstanding gaps:
+  - `ProfileActivityLogsItem.tsx` retains an `assertUnreachable` branch that could break when new log types arrive.
+  - Streaming utilities live inline inside the page, limiting reuse and making it harder to share cache hints across tabs.
+  - Only a single happy-path SSR test validates the streaming payload; no regression tests cover duplicate fetch prevention or error states.
+- Delivery tracked via TKT-0010 (umbrella) with phase tickets TKT-0011–TKT-0013.
+
+## Phase Plan
+
+### Phase 1 – Stabilise streaming data orchestration (1 sprint, ✅ complete)
+
+- **Scope:**
+  - Centralise identity-tab data prep inside the page with shared helpers (`createIdentityTabParams`, `createResource`) that normalise params, wrap fetches in server-timing instrumentation, and fall back safely on failure.
+  - Wire Suspense boundaries so statements, raters, and logs stream independently while `UserPageIdentityHydrator` seeds React Query with streamed payloads.
+  - Capture architecture in docs and keep SSR integration tests verifying layout props, hydrator payloads, and skeleton fallbacks.
+- **Deliverables:**
+  - Inline streaming utilities with cache-aware fetchers and graceful error handling.
+  - Jest integration coverage for the streaming pipeline.
+  - Updated Identity tab documentation describing the server-to-client flow.
+- **Dependencies:** None beyond existing APIs.
+- **Risks & Mitigations:** Inline helpers could drift—document conventions and share types to minimise divergence.
+- **Success Metrics:** Single server pass hydrates initial data with no duplicate client fetches (verified in tests); lint/test baselines stay green.
+
+### Phase 2 – Server-first read-only shells (1–2 sprints)
+
+- **Scope:**
+  - Elevate read-only sections into server components that consume the streamed payloads while leaving interactive controls client-side.
+    - Wrap `UserPageIdentityHeader` analytics in a server component with a dynamically imported rate CTA.
+    - Render statements and raters via server shells that output HTML for page one, then hand off to existing client controllers for CRUD/pagination.
+    - Refactor activity log rendering to remove `assertUnreachable` and provide resilient defaults for unknown log types.
+  - Replace React Query hydration with direct props where possible to reduce client work.
+- **Deliverables:**
+  - New server shells under `app/[user]/identity/_components` (or equivalent) composed with Suspense boundaries around interactive pieces.
+  - Updated tab wiring demonstrating clean server/client boundaries.
+  - Regression tests covering server-rendered HTML, pagination hand-off, and log-type fallbacks.
+- **Dependencies:** Phase 1 streaming helpers; ensure client-only libraries remain behind dynamic imports.
+- **Risks & Mitigations:** Potential bundle growth if dependencies leak—monitor bundle analysis and guard with lazy loading; validate streamed HTML size.
+- **Success Metrics:** Above-the-fold HTML includes header, statements, and first-page tables; lab FCP improves ≥10% with identical data payloads.
+
+### Phase 3 – Streaming, caching, and mutation harmonisation (2 sprints)
+
+- **Scope:**
+  - Layer route-level caching (`fetchCache`, `revalidateTag`, or segment-level `revalidatePath`) onto the streaming fetchers, tying invalidation to mutation success.
+  - Introduce server actions (or thin API bridges) for statements CRUD and rater filters to enable progressive enhancement while preserving optimistic UI.
+  - Expand telemetry around SSR execution time, cache hit ratio, hydration payload size, and mutation latency.
+- **Deliverables:**
+  - Cache strategy with documented invalidation hooks and instrumentation.
+  - Server actions / mutation bridges with unit and integration coverage.
+  - Monitoring dashboards or runbooks summarising new metrics.
+- **Dependencies:** Feature flags for server action rollout; coordination with infra for cache storage and invalidation semantics.
+- **Risks & Mitigations:** Mutation complexity risks regressions—maintain client fallbacks and add end-to-end coverage; ensure cache invalidation avoids thrash.
+- **Success Metrics:** ≥80% repeat visits served from cache, mutation latency within SLA, ≥15% reduction in client JS execution time per Web Vitals.
+
+## Cross-Cutting Tasks
+
+- Update developer docs and runbooks to reflect new SSR boundaries and testing expectations.
+- Keep TKT-0010 log in sync with phase progress; spin follow-up tickets per phase or component cluster.
+- Engage QA and design for snapshot updates as server-rendered HTML may affect visual regression baselines.
diff --git a/codex/tickets/TKT-0010.md b/codex/tickets/TKT-0010.md
new file mode 100644
index 0000000000..8d1f896522
--- /dev/null
+++ b/codex/tickets/TKT-0010.md
@@ -0,0 +1,32 @@
+---
+created: 2025-10-15
+id: TKT-0010
+owner: openai-assistant
+priority: P1
+status: In-Progress
+title: Phase roadmap for identity tab SSR migration
+---
+
+## Context
+
+> Capture a phased strategy to push the profile identity tab deeper into SSR, building on the recent hydration work and highlighting the sequencing, scope, and risks for each tranche.
+
+## Plan
+
+- [x] Document a multi-phase roadmap covering timeline, scope, and guardrails.
+- [ ] Align roadmap with engineering stakeholders and slot into delivery schedule.
+
+## Acceptance
+
+- [ ] Written plan outlines at least two phases with goals, dependencies, and owners.
+- [ ] Risks, testing strategy, and success metrics are captured for each phase.
+
+## Links
+
+- Primary PR: _(add when available)_
+- Follow-ups: _(reference additional tickets or TODO items)_
+
+## Log
+
+- 2025-10-15T00:00:00Z – Drafted initial roadmap concept.
+- 2025-10-15T00:08:00Z – Spun off follow-up tickets TKT-0011 through TKT-0013 for roadmap phases.
diff --git a/codex/tickets/TKT-0011.md b/codex/tickets/TKT-0011.md
new file mode 100644
index 0000000000..4d62128118
--- /dev/null
+++ b/codex/tickets/TKT-0011.md
@@ -0,0 +1,43 @@
+---
+created: 2025-10-15
+id: TKT-0011
+owner: openai-assistant
+priority: P1
+status: Review
+title: Harden identity SSR data contract
+---
+
+## Context
+
+> Phase 1 of the identity tab SSR roadmap focuses on stabilising server data preparation, ensuring deterministic payloads, and covering the server → client hydration path with tests.
+
+## Plan
+
+- [x] Centralise identity SSR queries under a typed `queries` module with consistent fallbacks.
+- [x] Align React Query keys and remove redundant `useEffect` hydration where props suffice.
+- [x] Add integration coverage to confirm the page renders with prefetched data and no extra fetches.
+- [x] Update identity developer docs to describe the refreshed data flow.
+
+## Acceptance
+
+- [x] Identity SSR helpers return typed results with shared error handling and caching hints.
+- [x] Jest/Playwright suite validates SSR payload usage without redundant client requests.
+- [x] Documentation changes reviewed with the identity squad.
+
+## Links
+
+- Primary PR: https://github.com/6529-Collections/6529seize-frontend/pull/1550
+- Follow-ups: [TKT-0012](codex/tickets/TKT-0012.md), [TKT-0013](codex/tickets/TKT-0013.md)
+
+## Log
+
+- 2025-10-15T00:05:00Z – Ticket created from Phase 1 roadmap scope.
+- 2025-10-15T01:00:00Z – Implemented shared identity query helper, simplified hydrator caching, and added unit coverage plus README notes.
+- 2025-10-15T02:45:00Z – Landed integration test covering SSR prepare hook and extended README testing guidance.
+- 2025-10-15T03:20:00Z – Normalised helper error handling, exposed cache hints/tags, and expanded unit tests to assert the new contract.
+- 2025-10-15T03:30:00Z – Documented Phase 1 snapshot for identity squad review and circulated follow-up questions.
+- 2025-10-15T04:00:00Z – Identity squad review complete; approvals recorded in project docs with no follow-up actions required.
+- 2025-10-16T09:15:00Z – Linked primary PR #1550 and mirrored the change on the Codex board.
+- 2025-10-16T09:45:00Z – Realigned identity tab query tests with helper defaults to unblock failing suite.
+- 2025-10-16T09:51:00Z – Added server timing instrumentation, cached profile fetches, and in-prepare header hydration to tighten identity tab SSR latency.
+- 2025-10-17T07:12:00Z – Refactored identity tab to stream via Suspense boundaries and updated SSR tests to exercise the new flow.
diff --git a/codex/tickets/TKT-0012.md b/codex/tickets/TKT-0012.md
new file mode 100644
index 0000000000..f89fa0df0b
--- /dev/null
+++ b/codex/tickets/TKT-0012.md
@@ -0,0 +1,36 @@
+---
+created: 2025-10-15
+id: TKT-0012
+owner: openai-assistant
+priority: P1
+status: Backlog
+title: Build server-first identity shells
+---
+
+## Context
+
+> Phase 2 of the identity tab SSR roadmap aims to move read-mostly widgets (header, statements list, raters/activity shells) into server components that stream initial HTML while keeping interactive controls client-side.
+
+## Plan
+
+- [ ] Split header, statements, and table components into server shells with client controllers for mutations.
+- [ ] Introduce Suspense/HydrationBoundary wrappers in `IdentityTab` for staged hydration.
+- [ ] Replace React Query hydration with direct props for read-only data paths.
+- [ ] Resolve `ProfileActivityLogType` fallback by removing `assertUnreachable` and providing a default renderer.
+- [ ] Add regression tests validating streamed HTML for above-the-fold content and pagination handoff.
+
+## Acceptance
+
+- [ ] Identity tab ships server-rendered HTML for header, statements, and first-page tables.
+- [ ] No runtime errors when new activity log types appear; default renderer verified.
+- [ ] Bundle analysis confirms no regressions in client JS size; tests cover server/client boundaries.
+
+## Links
+
+- Primary PR: _(add when available)_
+- Follow-ups: TKT-0013
+- Related: TKT-0011
+
+## Log
+
+- 2025-10-15T00:06:00Z – Ticket created for Phase 2 server-shell implementation.
diff --git a/codex/tickets/TKT-0013.md b/codex/tickets/TKT-0013.md
new file mode 100644
index 0000000000..45f6d9f7a9
--- /dev/null
+++ b/codex/tickets/TKT-0013.md
@@ -0,0 +1,34 @@
+---
+created: 2025-10-15
+id: TKT-0013
+owner: openai-assistant
+priority: P1
+status: Backlog
+title: Implement identity SSR streaming and mutations
+---
+
+## Context
+
+> Phase 3 of the identity tab SSR roadmap introduces caching, streaming, and server-action backed mutations to minimise client work while keeping optimistic UX intact.
+
+## Plan
+
+- [ ] Add route-level caching and revalidation tags for identity tab data sources.
+- [ ] Implement server actions (or equivalent API wrappers) for statements CRUD and raters/activity filters with progressive enhancement fallbacks.
+- [ ] Wire metrics/observability around SSR execution, cache hit rate, and hydration payload size.
+- [ ] Validate optimistic UI flows when mutations trigger partial revalidation.
+
+## Acceptance
+
+- [ ] Identity tab benefits from cache hits on revisit; instrumentation captures hit/miss ratios.
+- [ ] Server-backed mutations succeed with fallbacks for unsupported cases, and UI remains responsive.
+- [ ] Monitoring dashboards or logs document SSR performance improvements.
+
+## Links
+
+- Primary PR: _(add when available)_
+- Related: TKT-0011, TKT-0012
+
+## Log
+
+- 2025-10-15T00:07:00Z – Ticket created for Phase 3 streaming and mutation harmonisation.
diff --git a/components/profile-activity/ProfileActivityLogs.tsx b/components/profile-activity/ProfileActivityLogs.tsx
index 06a421d75c..32fbeb1f2d 100644
--- a/components/profile-activity/ProfileActivityLogs.tsx
+++ b/components/profile-activity/ProfileActivityLogs.tsx
@@ -4,7 +4,7 @@ import { ProfileActivityLog } from "@/entities/IProfile";
 import { CountlessPage } from "@/helpers/Types";
 import { commonApiFetch } from "@/services/api/common-api";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import CommonFilterTargetSelect from "../utils/CommonFilterTargetSelect";
 import ProfileActivityLogsFilter from "./filter/ProfileActivityLogsFilter";
 import ProfileActivityLogsList from "./list/ProfileActivityLogsList";
@@ -47,11 +47,13 @@ export default function ProfileActivityLogs({
   withFilters,
   disableActiveGroup = false,
   children,
+  initialData,
 }: {
   readonly initialParams: ActivityLogParams;
   readonly withFilters: boolean;
   readonly disableActiveGroup?: boolean;
   readonly children?: React.ReactNode;
+  readonly initialData?: CountlessPage<ProfileActivityLog>;
 }) {
   const activeGroupId = useSelector(selectActiveGroupId);
   const [selectedFilters, setSelectedFilters] = useState<
@@ -84,23 +86,8 @@ export default function ProfileActivityLogs({
     setCurrentPage(1);
   };
 
-  const [params, setParams] = useState<ActivityLogParamsConverted>(
-    convertActivityLogParams({
-      params: {
-        page: currentPage,
-        pageSize: initialParams.pageSize,
-        logTypes: selectedFilters,
-        matter: initialParams.matter,
-        targetType,
-        handleOrWallet: initialParams.handleOrWallet,
-        groupId: activeGroupId,
-      },
-      disableActiveGroup: !!disableActiveGroup,
-    })
-  );
-
-  useEffect(() => {
-    setParams(
+  const params = useMemo(
+    () =>
       convertActivityLogParams({
         params: {
           page: currentPage,
@@ -112,15 +99,20 @@ export default function ProfileActivityLogs({
           groupId: activeGroupId,
         },
         disableActiveGroup: !!disableActiveGroup,
-      })
-    );
-  }, [
-    currentPage,
-    selectedFilters,
-    initialParams.handleOrWallet,
-    targetType,
-    activeGroupId,
-  ]);
+      }),
+    [
+      currentPage,
+      selectedFilters,
+      initialParams.pageSize,
+      initialParams.matter,
+      initialParams.handleOrWallet,
+      targetType,
+      activeGroupId,
+      disableActiveGroup,
+    ]
+  );
+
+  const hasInitialData = !!initialData;
 
   const { isLoading, data: logs } = useQuery<CountlessPage<ProfileActivityLog>>(
     {
@@ -138,7 +130,12 @@ export default function ProfileActivityLogs({
           endpoint: `profile-logs`,
           params: params,
         }),
+      initialData,
       placeholderData: keepPreviousData,
+      staleTime: hasInitialData ? 30_000 : 0,
+      refetchOnMount: hasInitialData ? false : undefined,
+      refetchOnWindowFocus: hasInitialData ? false : undefined,
+      refetchOnReconnect: hasInitialData ? false : undefined,
     }
   );
 
diff --git a/components/profile-activity/ProfileName.tsx b/components/profile-activity/ProfileName.tsx
index 71841b5f80..738eb4bf07 100644
--- a/components/profile-activity/ProfileName.tsx
+++ b/components/profile-activity/ProfileName.tsx
@@ -6,10 +6,7 @@ import { createPossessionStr } from "@/helpers/Helpers";
 import { useIdentity } from "@/hooks/useIdentity";
 import { useParams } from "next/navigation";
 import { useEffect, useState } from "react";
-export enum ProfileNameType {
-  POSSESSION = "POSSESSION",
-  DEFAULT = "DEFAULT",
-}
+import { ProfileNameType } from "./profileName.types";
 
 export default function ProfileName({
   type,
diff --git a/components/profile-activity/list/ProfileActivityLogsItem.tsx b/components/profile-activity/list/ProfileActivityLogsItem.tsx
index 90d00f21f2..162e625da7 100644
--- a/components/profile-activity/list/ProfileActivityLogsItem.tsx
+++ b/components/profile-activity/list/ProfileActivityLogsItem.tsx
@@ -1,6 +1,5 @@
 import { ProfileActivityLog } from "@/entities/IProfile";
 import { ProfileActivityLogType } from "@/enums";
-import { assertUnreachable } from "@/helpers/AllowlistToolHelpers";
 import ProfileActivityLogBanner from "./items/ProfileActivityLogBanner";
 import ProfileActivityLogClassification from "./items/ProfileActivityLogClassification";
 import ProfileActivityLogContact from "./items/ProfileActivityLogContact";
@@ -16,6 +15,7 @@ import ProfileActivityLogProxyActionState from "./items/ProfileActivityLogProxyA
 import ProfileActivityLogRate from "./items/ProfileActivityLogRate";
 import ProfileActivityLogSocialMedia from "./items/ProfileActivityLogSocialMedia";
 import ProfileActivityLogSocialMediaVerificationPost from "./items/ProfileActivityLogSocialMediaVerificationPost";
+import ProfileActivityLogUnknown from "./items/ProfileActivityLogUnknown";
 
 export default function UserPageIdentityActivityLogItem({
   log,
@@ -64,6 +64,6 @@ export default function UserPageIdentityActivityLogItem({
     case ProfileActivityLogType.PROXY_DROP_RATING_EDIT:
       return <></>;
     default:
-      assertUnreachable(logType);
+      return <ProfileActivityLogUnknown log={log} />;
   }
 }
diff --git a/components/profile-activity/list/items/ProfileActivityLogUnknown.tsx b/components/profile-activity/list/items/ProfileActivityLogUnknown.tsx
new file mode 100644
index 0000000000..77a3919dc8
--- /dev/null
+++ b/components/profile-activity/list/items/ProfileActivityLogUnknown.tsx
@@ -0,0 +1,23 @@
+import type { ProfileActivityLog } from "@/entities/IProfile";
+import ProfileActivityLogItemAction from "./utils/ProfileActivityLogItemAction";
+
+export default function ProfileActivityLogUnknown({
+  log,
+}: {
+  readonly log: ProfileActivityLog;
+}) {
+  return (
+    <>
+      <ProfileActivityLogItemAction action="recorded" />
+      <span
+        data-testid="unknown-identity-activity"
+        className="tw-whitespace-nowrap tw-text-base tw-font-medium tw-text-neutral-100"
+      >
+        identity activity
+      </span>
+      <span className="tw-whitespace-nowrap tw-text-sm tw-text-iron-400 tw-font-medium">
+        ({log.type})
+      </span>
+    </>
+  );
+}
diff --git a/components/profile-activity/profileName.types.ts b/components/profile-activity/profileName.types.ts
new file mode 100644
index 0000000000..8f60de84dd
--- /dev/null
+++ b/components/profile-activity/profileName.types.ts
@@ -0,0 +1,4 @@
+export enum ProfileNameType {
+  POSSESSION = "POSSESSION",
+  DEFAULT = "DEFAULT",
+}
diff --git a/components/react-query-wrapper/ReactQueryWrapper.tsx b/components/react-query-wrapper/ReactQueryWrapper.tsx
index c3e0ca48f7..5bb3562b91 100644
--- a/components/react-query-wrapper/ReactQueryWrapper.tsx
+++ b/components/react-query-wrapper/ReactQueryWrapper.tsx
@@ -5,6 +5,7 @@ import {
   ApiProfileRepRatesState,
   ProfileActivityLog,
   RatingWithProfileInfoAndLevel,
+  CicStatement,
 } from "@/entities/IProfile";
 import { RateMatter } from "@/enums";
 import { ApiDrop } from "@/generated/models/ApiDrop";
@@ -110,9 +111,13 @@ interface InitProfileRepPageParams {
 
 interface InitProfileIdentityPageParams {
   readonly profile: ApiIdentity;
-  readonly activityLogs: InitProfileActivityLogsParams;
+  readonly activityLogs?: InitProfileActivityLogsParams | null;
   readonly cicGivenToUsers: InitProfileRatersParamsAndData;
   readonly cicReceivedFromUsers: InitProfileRatersParamsAndData;
+  readonly statements: {
+    readonly handleOrWallet: string;
+    readonly data: CicStatement[];
+  };
 }
 
 type ReactQueryWrapperContextType = {
@@ -770,15 +775,27 @@ export default function ReactQueryWrapper({
     activityLogs,
     cicGivenToUsers,
     cicReceivedFromUsers,
+    statements,
   }: InitProfileIdentityPageParams) => {
     setProfile(profile);
-    initProfileActivityLogs({
-      params: activityLogs.params,
-      data: activityLogs.data,
-      disableActiveGroup: true,
-    });
+    if (activityLogs) {
+      initProfileActivityLogs({
+        params: activityLogs.params,
+        data: activityLogs.data,
+        disableActiveGroup: true,
+      });
+    }
     setProfileRaters(cicGivenToUsers);
     setProfileRaters(cicReceivedFromUsers);
+    if (statements.handleOrWallet) {
+      queryClient.setQueryData<CicStatement[]>(
+        [
+          QueryKey.PROFILE_CIC_STATEMENTS,
+          statements.handleOrWallet.toLowerCase(),
+        ],
+        statements.data
+      );
+    }
   };
 
   const initCommunityActivityPage = ({
diff --git a/components/user/identity/README.md b/components/user/identity/README.md
new file mode 100644
index 0000000000..1c075237e7
--- /dev/null
+++ b/components/user/identity/README.md
@@ -0,0 +1,43 @@
+# Identity Tab Server Data Flow
+
+This directory renders the profile **Identity** tab. The route now orchestrates
+its server-side data fetching directly inside
+`app/[user]/identity/page.tsx`, streaming each section once its data resolves.
+
+## Server Orchestration
+
+- `IdentityTabContent` (in `app/[user]/identity/page.tsx`) builds the shared
+  params via `createIdentityTabParams`, then spins up cached fetchers for
+  statements, raters, and the activity log. Each fetch uses a `createResource`
+  guard so failures log a warning and fall back to safe defaults instead of
+  breaking the stream.
+- Server wrappers under `app/[user]/identity/_components` (`IdentityHydratorSection`,
+  `IdentityContentShell`, etc.) render the initial HTML for statements, raters,
+  and activity logs while deferring interactive pieces to client components.
+- Suspense boundaries wrap every section, allowing the header to render
+  immediately while tables and logs hydrate as their promises settle.
+
+## Hydration
+
+- `UserPageIdentityHydrator` seeds React Query with any preloaded payloads. It
+  primes statements and both raters tables, and seeds activity logs only when
+  the server run returned data, keeping the client query path authoritative.
+
+## Client Components
+
+- `UserPageIdentityStatements` and `ProfileRatersTableWrapper` remain client
+  components so their interactive modals, filters, and pagination stay intact.
+  They use the streamed `initialData` to skip redundant refetches.
+- `UserPageIdentityActivityLog` still defers to `ProfileActivityLogs`, which
+  hydrates from the optional server payload and continues fetching on the
+  client when the user filters or paginates.
+- Unknown activity log types now fall back to a resilient
+  `ProfileActivityLogUnknown` renderer instead of triggering an assertion.
+
+## Testing Notes
+
+- `__tests__/components/react-query-wrapper/ReactQueryWrapper.test.tsx`
+  covers the cache priming performed by `initProfileIdentityPage`.
+- `__tests__/app/identityPageSSR.test.tsx` exercises the Identity tab streaming
+  flow, ensuring layout props, hydrator payloads, and Suspense boundaries behave
+  as expected.
diff --git a/components/user/identity/UserPageIdentity.tsx b/components/user/identity/UserPageIdentity.tsx
index 396cdaaa5e..32abb973c1 100644
--- a/components/user/identity/UserPageIdentity.tsx
+++ b/components/user/identity/UserPageIdentity.tsx
@@ -1,36 +1,65 @@
-import { ApiIdentity } from "@/generated/models/ApiIdentity";
-import UserPageIdentityStatements from "./statements/UserPageIdentityStatements";
-import UserPageIdentityHeader from "./header/UserPageIdentityHeader";
 import { ActivityLogParams } from "@/components/profile-activity/ProfileActivityLogs";
+import { ApiIdentity } from "@/generated/models/ApiIdentity";
+import { CountlessPage, Page } from "@/helpers/Types";
+import {
+  CicStatement,
+  ProfileActivityLog,
+  RatingWithProfileInfoAndLevel,
+} from "@/entities/IProfile";
 import ProfileRatersTableWrapper, {
   ProfileRatersParams,
 } from "../utils/raters-table/wrapper/ProfileRatersTableWrapper";
 import UserPageIdentityActivityLog from "./activity/UserPageIdentityActivityLog";
+import UserPageIdentityHeader from "./header/UserPageIdentityHeader";
+import UserPageIdentityStatements from "./statements/UserPageIdentityStatements";
 
 export default function UserPageIdentity({
   profile,
   initialCICReceivedParams,
   initialCICGivenParams,
   initialActivityLogParams,
+  handleOrWallet,
+  initialStatements,
+  initialCicGivenData,
+  initialCicReceivedData,
+  initialActivityLogData,
 }: {
   readonly profile: ApiIdentity;
   readonly initialCICReceivedParams: ProfileRatersParams;
   readonly initialCICGivenParams: ProfileRatersParams;
   readonly initialActivityLogParams: ActivityLogParams;
+  readonly handleOrWallet: string;
+  readonly initialStatements: CicStatement[];
+  readonly initialCicGivenData: Page<RatingWithProfileInfoAndLevel>;
+  readonly initialCicReceivedData: Page<RatingWithProfileInfoAndLevel>;
+  readonly initialActivityLogData?: CountlessPage<ProfileActivityLog>;
 }) {
   return (
     <div className="tailwind-scope">
       <UserPageIdentityHeader profile={profile} />
-      <UserPageIdentityStatements profile={profile} />
+      <UserPageIdentityStatements
+        profile={profile}
+        handleOrWallet={handleOrWallet}
+        initialStatements={initialStatements}
+      />
 
       <div className="tw-mt-6 lg:tw-mt-10 xl:tw-flex xl:tw-items-stretch tw-space-y-8 lg:tw-space-y-10 xl:tw-space-y-0 tw-gap-x-8">
-        <ProfileRatersTableWrapper initialParams={initialCICGivenParams} />
-        <ProfileRatersTableWrapper initialParams={initialCICReceivedParams} />
+        <ProfileRatersTableWrapper
+          initialParams={initialCICGivenParams}
+          handleOrWallet={handleOrWallet}
+          initialData={initialCicGivenData}
+        />
+        <ProfileRatersTableWrapper
+          initialParams={initialCICReceivedParams}
+          handleOrWallet={handleOrWallet}
+          initialData={initialCicReceivedData}
+        />
       </div>
 
       <div className="tw-mt-8 lg:tw-mt-10">
         <UserPageIdentityActivityLog
           initialActivityLogParams={initialActivityLogParams}
+          initialActivityLogData={initialActivityLogData}
         />
       </div>
     </div>
diff --git a/components/user/identity/UserPageIdentityHydrator.tsx b/components/user/identity/UserPageIdentityHydrator.tsx
new file mode 100644
index 0000000000..f9a4480b68
--- /dev/null
+++ b/components/user/identity/UserPageIdentityHydrator.tsx
@@ -0,0 +1,82 @@
+"use client";
+
+import { useEffect, useContext, useMemo } from "react";
+
+import { ReactQueryWrapperContext } from "@/components/react-query-wrapper/ReactQueryWrapper";
+import type { ActivityLogParams } from "@/components/profile-activity/ProfileActivityLogs";
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import type {
+  CicStatement,
+  ProfileActivityLog,
+  RatingWithProfileInfoAndLevel,
+} from "@/entities/IProfile";
+import type { CountlessPage, Page } from "@/helpers/Types";
+import type { ProfileRatersParams } from "../utils/raters-table/wrapper/ProfileRatersTableWrapper";
+
+type Props = {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly initialStatements: CicStatement[];
+  readonly initialActivityLogParams: ActivityLogParams;
+  readonly initialActivityLogData?: CountlessPage<ProfileActivityLog>;
+  readonly initialCICGivenParams: ProfileRatersParams;
+  readonly initialCicGivenData: Page<RatingWithProfileInfoAndLevel>;
+  readonly initialCICReceivedParams: ProfileRatersParams;
+  readonly initialCicReceivedData: Page<RatingWithProfileInfoAndLevel>;
+};
+
+export default function UserPageIdentityHydrator({
+  profile,
+  handleOrWallet,
+  initialStatements,
+  initialActivityLogParams,
+  initialActivityLogData,
+  initialCICGivenParams,
+  initialCicGivenData,
+  initialCICReceivedParams,
+  initialCicReceivedData,
+}: Readonly<Props>) {
+  const normalizedHandle = handleOrWallet.toLowerCase();
+  const { initProfileIdentityPage } = useContext(ReactQueryWrapperContext);
+  const activityLogsPayload = useMemo(
+    () =>
+      initialActivityLogData
+        ? {
+            params: initialActivityLogParams,
+            data: initialActivityLogData,
+          }
+        : undefined,
+    [initialActivityLogParams, initialActivityLogData]
+  );
+
+  useEffect(() => {
+    initProfileIdentityPage({
+      profile,
+      activityLogs: activityLogsPayload,
+      cicGivenToUsers: {
+        params: initialCICGivenParams,
+        data: initialCicGivenData,
+      },
+      cicReceivedFromUsers: {
+        params: initialCICReceivedParams,
+        data: initialCicReceivedData,
+      },
+      statements: {
+        handleOrWallet: normalizedHandle,
+        data: initialStatements,
+      },
+    });
+  }, [
+    initProfileIdentityPage,
+    profile,
+    activityLogsPayload,
+    initialCICGivenParams,
+    initialCicGivenData,
+    initialCICReceivedParams,
+    initialCicReceivedData,
+    initialStatements,
+    normalizedHandle,
+  ]);
+
+  return null;
+}
diff --git a/components/user/identity/UserPageIdentityWrapper.tsx b/components/user/identity/UserPageIdentityWrapper.tsx
index a3e2becc1d..71efd59414 100644
--- a/components/user/identity/UserPageIdentityWrapper.tsx
+++ b/components/user/identity/UserPageIdentityWrapper.tsx
@@ -2,8 +2,13 @@
 
 import { ActivityLogParams } from "@/components/profile-activity/ProfileActivityLogs";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
+import { CountlessPage, Page } from "@/helpers/Types";
+import {
+  CicStatement,
+  ProfileActivityLog,
+  RatingWithProfileInfoAndLevel,
+} from "@/entities/IProfile";
 import { useIdentity } from "@/hooks/useIdentity";
-import { useParams } from "next/navigation";
 import { ProfileRatersParams } from "../utils/raters-table/wrapper/ProfileRatersTableWrapper";
 import UserPageSetUpProfileWrapper from "../utils/set-up-profile/UserPageSetUpProfileWrapper";
 import UserPageIdentity from "./UserPageIdentity";
@@ -13,27 +18,46 @@ export default function UserPageIdentityWrapper({
   initialCICReceivedParams,
   initialCICGivenParams,
   initialActivityLogParams,
+  handleOrWallet,
+  initialStatements,
+  initialCicGivenData,
+  initialCicReceivedData,
+  initialActivityLogData,
 }: {
   readonly profile: ApiIdentity;
   readonly initialCICReceivedParams: ProfileRatersParams;
   readonly initialCICGivenParams: ProfileRatersParams;
   readonly initialActivityLogParams: ActivityLogParams;
+  readonly handleOrWallet: string;
+  readonly initialStatements: CicStatement[];
+  readonly initialCicGivenData: Page<RatingWithProfileInfoAndLevel>;
+  readonly initialCicReceivedData: Page<RatingWithProfileInfoAndLevel>;
+  readonly initialActivityLogData?: CountlessPage<ProfileActivityLog>;
 }) {
-  const params = useParams();
-  const user = (params?.user as string)?.toLowerCase();
+  const normalizedHandle = handleOrWallet.toLowerCase();
 
-  const { profile } = useIdentity({
-    handleOrWallet: user,
-    initialProfile: initialProfile,
+  const { profile: hydratedProfile } = useIdentity({
+    handleOrWallet: normalizedHandle,
+    initialProfile,
   });
 
+  const resolvedProfile = hydratedProfile ?? initialProfile;
+
   return (
-    <UserPageSetUpProfileWrapper profile={profile ?? initialProfile}>
+    <UserPageSetUpProfileWrapper
+      profile={resolvedProfile}
+      handleOrWallet={normalizedHandle}
+    >
       <UserPageIdentity
-        profile={profile ?? initialProfile}
+        profile={resolvedProfile}
         initialCICReceivedParams={initialCICReceivedParams}
         initialCICGivenParams={initialCICGivenParams}
         initialActivityLogParams={initialActivityLogParams}
+        handleOrWallet={normalizedHandle}
+        initialStatements={initialStatements}
+        initialCicGivenData={initialCicGivenData}
+        initialCicReceivedData={initialCicReceivedData}
+        initialActivityLogData={initialActivityLogData}
       />
     </UserPageSetUpProfileWrapper>
   );
diff --git a/components/user/identity/activity/UserPageIdentityActivityLog.tsx b/components/user/identity/activity/UserPageIdentityActivityLog.tsx
index f0ddd12206..173b9f6fe3 100644
--- a/components/user/identity/activity/UserPageIdentityActivityLog.tsx
+++ b/components/user/identity/activity/UserPageIdentityActivityLog.tsx
@@ -1,15 +1,18 @@
 import ProfileActivityLogs, {
   ActivityLogParams,
 } from "@/components/profile-activity/ProfileActivityLogs";
-import ProfileName, {
-  ProfileNameType,
-} from "@/components/profile-activity/ProfileName";
+import ProfileName from "@/components/profile-activity/ProfileName";
+import { ProfileNameType } from "@/components/profile-activity/profileName.types";
 import UserTableHeaderWrapper from "@/components/user/utils/UserTableHeaderWrapper";
+import { CountlessPage } from "@/helpers/Types";
+import { ProfileActivityLog } from "@/entities/IProfile";
 
 export default function UserPageIdentityActivityLog({
   initialActivityLogParams,
+  initialActivityLogData,
 }: {
   readonly initialActivityLogParams: ActivityLogParams;
+  readonly initialActivityLogData?: CountlessPage<ProfileActivityLog>;
 }) {
   return (
     <div>
@@ -23,6 +26,7 @@ export default function UserPageIdentityActivityLog({
         <ProfileActivityLogs
           initialParams={initialActivityLogParams}
           withFilters={true}
+          initialData={initialActivityLogData}
         />
       </div>
     </div>
diff --git a/components/user/identity/header/UserPageIdentityHeader.tsx b/components/user/identity/header/UserPageIdentityHeader.tsx
index cc69f12a57..f277ee2355 100644
--- a/components/user/identity/header/UserPageIdentityHeader.tsx
+++ b/components/user/identity/header/UserPageIdentityHeader.tsx
@@ -1,8 +1,6 @@
-import UserPageRateWrapper from "@/components/user/utils/rate/UserPageRateWrapper";
-import { RateMatter } from "@/enums";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
-import UserPageIdentityHeaderCICRate from "./cic-rate/UserPageIdentityHeaderCICRate";
 import UserPageIdentityHeaderCIC from "./UserPageIdentityHeaderCIC";
+import UserPageIdentityHeaderActionsClient from "./UserPageIdentityHeaderActionsClient";
 
 export default function UserPageIdentityHeader({
   profile,
@@ -23,12 +21,7 @@ export default function UserPageIdentityHeader({
             </p>
           </div>
           <UserPageIdentityHeaderCIC profile={profile} />
-          <UserPageRateWrapper profile={profile} type={RateMatter.NIC}>
-            <UserPageIdentityHeaderCICRate
-              profile={profile}
-              isTooltip={false}
-            />
-          </UserPageRateWrapper>
+          <UserPageIdentityHeaderActionsClient profile={profile} />
         </div>
       </div>
     </div>
diff --git a/components/user/identity/header/UserPageIdentityHeaderActionsClient.tsx b/components/user/identity/header/UserPageIdentityHeaderActionsClient.tsx
new file mode 100644
index 0000000000..cc4cc16c58
--- /dev/null
+++ b/components/user/identity/header/UserPageIdentityHeaderActionsClient.tsx
@@ -0,0 +1,23 @@
+"use client";
+
+import UserPageRateWrapper from "@/components/user/utils/rate/UserPageRateWrapper";
+import { RateMatter } from "@/enums";
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import dynamic from "next/dynamic";
+
+const UserPageIdentityHeaderCICRate = dynamic(
+  () => import("./cic-rate/UserPageIdentityHeaderCICRate"),
+  { ssr: false }
+);
+
+export default function UserPageIdentityHeaderActionsClient({
+  profile,
+}: {
+  readonly profile: ApiIdentity;
+}) {
+  return (
+    <UserPageRateWrapper profile={profile} type={RateMatter.NIC}>
+      <UserPageIdentityHeaderCICRate profile={profile} isTooltip={false} />
+    </UserPageRateWrapper>
+  );
+}
diff --git a/components/user/identity/header/UserPageIdentityHeaderCIC.tsx b/components/user/identity/header/UserPageIdentityHeaderCIC.tsx
index ca9d6420f4..85b3823fe3 100644
--- a/components/user/identity/header/UserPageIdentityHeaderCIC.tsx
+++ b/components/user/identity/header/UserPageIdentityHeaderCIC.tsx
@@ -1,6 +1,5 @@
-"use client";
+'use client';
 
-import { useEffect, useState } from "react";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
 import { formatNumberWithCommas } from "@/helpers/Helpers";
 import UserCICTypeIconWrapper from "@/components/user/utils/user-cic-type/UserCICTypeIconWrapper";
@@ -11,11 +10,7 @@ export default function UserPageIdentityHeaderCIC({
 }: {
   readonly profile: ApiIdentity;
 }) {
-  const [cicRating, setCicRating] = useState<number>(profile.cic);
-
-  useEffect(() => {
-    setCicRating(profile.cic);
-  }, [profile]);
+  const cicRating = profile.cic;
 
   return (
     <div className="tw-mb-6 tw-mt-4 tw-flex tw-flex-col sm:tw-flex-row sm:tw-flex-wrap sm:tw-space-x-6 tw-gap-y-1">
diff --git a/components/user/identity/statements/UserPageIdentityStatements.tsx b/components/user/identity/statements/UserPageIdentityStatements.tsx
index 1821b5f5d7..965b496bb9 100644
--- a/components/user/identity/statements/UserPageIdentityStatements.tsx
+++ b/components/user/identity/statements/UserPageIdentityStatements.tsx
@@ -5,10 +5,12 @@ import { CicStatement } from "@/entities/IProfile";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
 import { STATEMENT_GROUP } from "@/helpers/Types";
 import { commonApiFetch } from "@/services/api/common-api";
+import { faCircleQuestion } from "@fortawesome/free-regular-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import { useQuery } from "@tanstack/react-query";
-import { useParams } from "next/navigation";
-import { useEffect, useState } from "react";
+import { useMemo } from "react";
 import { Tooltip } from "react-tooltip";
+import { useParams } from "next/navigation";
 import UserPageIdentityStatementsConsolidatedAddresses from "./consolidated-addresses/UserPageIdentityStatementsConsolidatedAddresses";
 import UserPageIdentityStatementsContacts from "./contacts/UserPageIdentityStatementsContacts";
 import UserPageIdentityAddStatementsHeader from "./header/UserPageIdentityAddStatementsHeader";
@@ -17,64 +19,73 @@ import UserPageIdentityStatementsSocialMediaAccounts from "./social-media-accoun
 import UserPageIdentityStatementsSocialMediaVerificationPosts from "./social-media-verification-posts/UserPageIdentityStatementsSocialMediaVerificationPosts";
 export default function UserPageIdentityStatements({
   profile,
+  handleOrWallet,
+  initialStatements,
 }: {
   readonly profile: ApiIdentity;
+  readonly handleOrWallet?: string;
+  readonly initialStatements: CicStatement[];
 }) {
-  const params = useParams();
-  const user = (params?.user as string)?.toLowerCase();
-  const [socialMediaAccounts, setSocialMediaAccounts] = useState<
-    CicStatement[]
-  >([]);
-
-  const [contacts, setContacts] = useState<CicStatement[]>([]);
-  const [nftAccounts, setNftAccounts] = useState<CicStatement[]>([]);
-  const [socialMediaVerificationPosts, setSocialMediaVerificationPosts] =
-    useState<CicStatement[]>([]);
+  const params = useParams<{ user?: string | string[] }>();
+  const paramHandle = Array.isArray(params?.user)
+    ? params?.user?.[0]
+    : params?.user;
+  const fallbackHandle =
+    handleOrWallet ??
+    profile.handle ??
+    profile.wallets?.[0]?.wallet ??
+    paramHandle ??
+    "";
+  const normalizedHandle = fallbackHandle.toLowerCase();
 
-  const { isLoading, data: statements } = useQuery<CicStatement[]>({
-    queryKey: [QueryKey.PROFILE_CIC_STATEMENTS, user.toLowerCase()],
+  const { isLoading, data: statements = [] } = useQuery<CicStatement[]>({
+    queryKey: [QueryKey.PROFILE_CIC_STATEMENTS, normalizedHandle],
     queryFn: async () =>
       await commonApiFetch<CicStatement[]>({
-        endpoint: `profiles/${user}/cic/statements`,
+        endpoint: `profiles/${normalizedHandle}/cic/statements`,
       }),
-    enabled: !!user,
+    enabled: !!normalizedHandle,
+    initialData: initialStatements,
   });
 
-  useEffect(() => {
-    if (!statements) {
-      setNftAccounts([]);
-      setSocialMediaAccounts([]);
-      setContacts([]);
-      setSocialMediaVerificationPosts([]);
-      return;
-    }
-    const sortedStatements = [...statements].sort((a, d) => {
+  const sortedStatements = useMemo(() => {
+    return [...statements].sort((a, d) => {
       return new Date(d.crated_at).getTime() - new Date(a.crated_at).getTime();
     });
-    setSocialMediaAccounts(
+  }, [statements]);
+
+  const socialMediaAccounts = useMemo(
+    () =>
       sortedStatements.filter(
         (s) => s.statement_group === STATEMENT_GROUP.SOCIAL_MEDIA_ACCOUNT
-      )
-    );
-    setContacts(
+      ),
+    [sortedStatements]
+  );
+
+  const contacts = useMemo(
+    () =>
       sortedStatements.filter(
         (s) => s.statement_group === STATEMENT_GROUP.CONTACT
-      )
-    );
+      ),
+    [sortedStatements]
+  );
 
-    setNftAccounts(
+  const nftAccounts = useMemo(
+    () =>
       sortedStatements.filter(
         (s) => s.statement_group === STATEMENT_GROUP.NFT_ACCOUNTS
-      )
-    );
+      ),
+    [sortedStatements]
+  );
 
-    setSocialMediaVerificationPosts(
+  const socialMediaVerificationPosts = useMemo(
+    () =>
       sortedStatements.filter(
         (s) =>
           s.statement_group === STATEMENT_GROUP.SOCIAL_MEDIA_VERIFICATION_POST
-      )
-    );
-  }, [statements]);
+      ),
+    [sortedStatements]
+  );
 
   return (
     <div className="tw-mt-6 lg:tw-mt-8">
@@ -126,20 +137,11 @@ export default function UserPageIdentityStatements({
                       aria-label="Statements help"
                       className="tw-rounded-full tw-h-10 tw-w-10 tw-inline-flex tw-items-center tw-justify-center focus:tw-outline-none focus:tw-ring-1 focus:tw-ring-inset focus:tw-ring-primary-400"
                       data-tooltip-id="statements-help">
-                      <svg
+                      <FontAwesomeIcon
+                        icon={faCircleQuestion}
                         className="tw-flex-shrink-0 tw-w-5 tw-h-5 tw-text-iron-400"
-                        viewBox="0 0 24 24"
-                        fill="none"
                         aria-hidden="true"
-                        xmlns="http://www.w3.org/2000/svg">
-                        <path
-                          d="M12 16V12M12 8H12.01M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z"
-                          stroke="currentColor"
-                          strokeWidth="2"
-                          strokeLinecap="round"
-                          strokeLinejoin="round"
-                        />
-                      </svg>
+                      />
                     </div>
                     <Tooltip
                       id="statements-help"
diff --git a/components/user/layout/UserPageLayout.tsx b/components/user/layout/UserPageLayout.tsx
index aa18b9def4..160da244d5 100644
--- a/components/user/layout/UserPageLayout.tsx
+++ b/components/user/layout/UserPageLayout.tsx
@@ -1,18 +1,38 @@
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
-import { ReactNode } from "react";
+import { CicStatement } from "@/entities/IProfile";
+import { ReactNode, Suspense } from "react";
+import CommonSkeletonLoader from "@/components/utils/animation/CommonSkeletonLoader";
 import UserPageHeader from "../user-page-header/UserPageHeader";
 import UserPageTabs from "./UserPageTabs";
 import UserPageClientHydrator from "./UserPageClientHydrator";
 
+export type UserPageLayoutProps = {
+  readonly profile: ApiIdentity;
+  readonly handleOrWallet: string;
+  readonly children: ReactNode;
+  readonly initialStatements?: CicStatement[];
+  readonly profileEnabledAt?: string | null;
+  readonly followersCount?: number | null;
+};
+
+function UserPageHeaderFallback() {
+  return (
+    <div className="tw-bg-iron-900 tw-border-b tw-border-iron-800 tw-py-8">
+      <div className="tw-px-2 lg:tw-px-6 xl:tw-px-8 tw-mx-auto">
+        <CommonSkeletonLoader />
+      </div>
+    </div>
+  );
+}
+
 export default function UserPageLayout({
   profile: initialProfile,
   handleOrWallet,
   children,
-}: {
-  readonly profile: ApiIdentity;
-  readonly handleOrWallet: string;
-  readonly children: ReactNode;
-}) {
+  initialStatements,
+  profileEnabledAt,
+  followersCount,
+}: Readonly<UserPageLayoutProps>) {
   const normalizedHandleOrWallet = handleOrWallet.toLowerCase();
   const mainAddress =
     initialProfile?.primary_wallet ?? normalizedHandleOrWallet;
@@ -24,11 +44,16 @@ export default function UserPageLayout({
         handleOrWallet={normalizedHandleOrWallet}
       />
       <div className="tw-bg-iron-950 tw-min-h-screen tw-pb-16 lg:tw-pb-20">
-        <UserPageHeader
-          profile={initialProfile}
-          handleOrWallet={normalizedHandleOrWallet}
-          fallbackMainAddress={mainAddress}
-        />
+        <Suspense fallback={<UserPageHeaderFallback />}>
+          <UserPageHeader
+            profile={initialProfile}
+            handleOrWallet={normalizedHandleOrWallet}
+            fallbackMainAddress={mainAddress}
+            initialStatements={initialStatements}
+            profileEnabledAt={profileEnabledAt}
+            followersCount={followersCount}
+          />
+        </Suspense>
         <div className="tw-px-2 lg:tw-px-6 xl:tw-px-8 tw-mx-auto">
           <UserPageTabs />
           <div className="tw-mt-6 lg:tw-mt-8">{children}</div>
diff --git a/components/user/rep/UserPageRepActivityLog.tsx b/components/user/rep/UserPageRepActivityLog.tsx
index 57e50e0abe..93a1f656ea 100644
--- a/components/user/rep/UserPageRepActivityLog.tsx
+++ b/components/user/rep/UserPageRepActivityLog.tsx
@@ -1,9 +1,8 @@
 import ProfileActivityLogs, {
   ActivityLogParams,
 } from "@/components/profile-activity/ProfileActivityLogs";
-import ProfileName, {
-  ProfileNameType,
-} from "@/components/profile-activity/ProfileName";
+import ProfileName from "@/components/profile-activity/ProfileName";
+import { ProfileNameType } from "@/components/profile-activity/profileName.types";
 import UserTableHeaderWrapper from "../utils/UserTableHeaderWrapper";
 
 export default function UserPageRepActivityLog({
diff --git a/components/user/user-page-header/UserPageHeader.tsx b/components/user/user-page-header/UserPageHeader.tsx
index 1b12de5426..1411ef9cc7 100644
--- a/components/user/user-page-header/UserPageHeader.tsx
+++ b/components/user/user-page-header/UserPageHeader.tsx
@@ -4,105 +4,91 @@ import { notFound } from "next/navigation";
 
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
 import { CicStatement, ProfileActivityLog } from "@/entities/IProfile";
-import { SortDirection } from "@/entities/ISort";
 import { CountlessPage } from "@/helpers/Types";
-import { ApiIncomingIdentitySubscriptionsPage } from "@/generated/models/ApiIncomingIdentitySubscriptionsPage";
 import { getAppCommonHeaders } from "@/helpers/server.app.helpers";
-import { commonApiFetch } from "@/services/api/common-api";
 
 import UserPageHeaderClient from "./UserPageHeaderClient";
 import { getRandomColor } from "@/helpers/Helpers";
-
-async function fetchStatements(
-  handleOrWallet: string,
-  headers: Record<string, string>
-) {
-  return await commonApiFetch<CicStatement[]>({
-    endpoint: `profiles/${handleOrWallet}/cic/statements`,
-    headers,
-  });
-}
-
-async function fetchProfileEnabledLog(
-  handleOrWallet: string,
-  headers: Record<string, string>
-) {
-  return await commonApiFetch<CountlessPage<ProfileActivityLog>>({
-    endpoint: "profile-logs",
-    params: {
-      profile: handleOrWallet,
-      log_type: "PROFILE_CREATED",
-      page_size: "1",
-      sort: "created_at",
-      sort_direction: SortDirection.ASC,
-    },
-    headers,
-  });
-}
-
-async function fetchFollowersCount(
-  profileId: string | number | null | undefined,
-  headers: Record<string, string>
-) {
-  if (!profileId) {
-    return null;
-  }
-
-  const response = await commonApiFetch<ApiIncomingIdentitySubscriptionsPage>({
-    endpoint: `identity-subscriptions/incoming/IDENTITY/${profileId}`,
-    params: {
-      page_size: "1",
-    },
-    headers,
-  });
-
-  return response.count ?? null;
-}
-
-function extractProfileEnabledAt(
-  logPage: CountlessPage<ProfileActivityLog> | null
-): string | null {
-  if (!logPage?.data?.length) {
-    return null;
-  }
-  const createdAt = logPage.data[0]?.created_at;
-  if (!createdAt) {
-    return null;
-  }
-  return new Date(createdAt).toISOString();
-}
+import {
+  extractProfileEnabledAt,
+} from "./userPageHeaderData";
+import {
+  fetchHeaderFollowersCount,
+  fetchHeaderProfileLog,
+  fetchHeaderStatements,
+} from "./userPageHeaderPrefetch";
 
 type Props = {
   readonly profile: ApiIdentity;
   readonly handleOrWallet: string;
   readonly fallbackMainAddress: string;
+  readonly initialStatements?: CicStatement[];
+  readonly profileEnabledAt?: string | null;
+  readonly followersCount?: number | null;
 };
 
 export default async function UserPageHeader({
   profile,
   handleOrWallet,
   fallbackMainAddress,
+  initialStatements,
+  profileEnabledAt,
+  followersCount,
 }: Readonly<Props>) {
   if (!handleOrWallet) {
     notFound();
   }
 
-  const headers = await getAppCommonHeaders();
   const normalizedHandle = handleOrWallet.toLowerCase();
 
-  const [statementsResult, profileLogResult, followersResult] =
+  let cachedHeaders: Record<string, string> | null = null;
+  const ensureHeaders = async () => {
+    if (cachedHeaders === null) {
+      cachedHeaders = await getAppCommonHeaders();
+    }
+    return cachedHeaders;
+  };
+
+  const statementsPromise: Promise<CicStatement[]> =
+    initialStatements === undefined
+      ? fetchHeaderStatements(normalizedHandle, await ensureHeaders())
+      : Promise.resolve(initialStatements ?? []);
+
+  const profileLogPromise: Promise<CountlessPage<ProfileActivityLog> | null> =
+    profileEnabledAt === undefined
+      ? fetchHeaderProfileLog(normalizedHandle, await ensureHeaders())
+      : Promise.resolve(null);
+
+  const followersPromise: Promise<number | null> =
+    followersCount === undefined
+      ? fetchHeaderFollowersCount(profile.id, await ensureHeaders())
+      : Promise.resolve(followersCount ?? null);
+
+  const [statementsResult, profileLogResult, resolvedFollowersResult] =
     await Promise.allSettled([
-      fetchStatements(normalizedHandle, headers),
-      fetchProfileEnabledLog(normalizedHandle, headers),
-      fetchFollowersCount(profile.id, headers),
+      statementsPromise,
+      profileLogPromise,
+      followersPromise,
     ]);
 
   const statements: CicStatement[] =
-    statementsResult.status === "fulfilled" ? statementsResult.value : [];
+    statementsResult.status === "fulfilled"
+      ? statementsResult.value
+      : initialStatements ?? [];
 
-  const profileLog: CountlessPage<ProfileActivityLog> | null =
+  const fetchedProfileLog: CountlessPage<ProfileActivityLog> | null =
     profileLogResult.status === "fulfilled" ? profileLogResult.value : null;
 
+  const resolvedProfileEnabledAt =
+    profileEnabledAt !== undefined
+      ? profileEnabledAt
+      : extractProfileEnabledAt(fetchedProfileLog);
+
+  const resolvedFollowersCount =
+    resolvedFollowersResult.status === "fulfilled"
+      ? resolvedFollowersResult.value
+      : followersCount ?? null;
+
   const defaultBanner1 = getRandomColor();
   const defaultBanner2 = getRandomColor();
 
@@ -114,10 +100,8 @@ export default async function UserPageHeader({
       defaultBanner1={defaultBanner1}
       defaultBanner2={defaultBanner2}
       initialStatements={statements}
-      profileEnabledAt={extractProfileEnabledAt(profileLog)}
-      followersCount={
-        followersResult.status === "fulfilled" ? followersResult.value : null
-      }
+      profileEnabledAt={resolvedProfileEnabledAt}
+      followersCount={resolvedFollowersCount}
     />
   );
 }
diff --git a/components/user/user-page-header/userPageHeaderData.ts b/components/user/user-page-header/userPageHeaderData.ts
new file mode 100644
index 0000000000..1524a2fe8d
--- /dev/null
+++ b/components/user/user-page-header/userPageHeaderData.ts
@@ -0,0 +1,71 @@
+import { CountlessPage } from "@/helpers/Types";
+import { SortDirection } from "@/entities/ISort";
+import { ProfileActivityLog } from "@/entities/IProfile";
+import { ApiIncomingIdentitySubscriptionsPage } from "@/generated/models/ApiIncomingIdentitySubscriptionsPage";
+import { withServerTiming } from "@/helpers/performance.helpers";
+import { commonApiFetch } from "@/services/api/common-api";
+
+type Headers = Record<string, string>;
+
+export async function fetchProfileEnabledLog({
+  handleOrWallet,
+  headers,
+}: {
+  readonly handleOrWallet: string;
+  readonly headers: Headers;
+}): Promise<CountlessPage<ProfileActivityLog>> {
+  return await withServerTiming(
+    `identity-profile-log:${handleOrWallet}`,
+    async () =>
+      await commonApiFetch<CountlessPage<ProfileActivityLog>>({
+        endpoint: "profile-logs",
+        params: {
+          profile: handleOrWallet,
+          log_type: "PROFILE_CREATED",
+          page_size: "1",
+          sort: "created_at",
+          sort_direction: SortDirection.ASC,
+        },
+        headers,
+      })
+  );
+}
+
+export async function fetchFollowersCount({
+  profileId,
+  headers,
+}: {
+  readonly profileId: string | number | null | undefined;
+  readonly headers: Headers;
+}): Promise<number | null> {
+  if (!profileId) {
+    return null;
+  }
+
+  const response = await withServerTiming(
+    `identity-followers:${profileId}`,
+    async () =>
+      await commonApiFetch<ApiIncomingIdentitySubscriptionsPage>({
+        endpoint: `identity-subscriptions/incoming/IDENTITY/${profileId}`,
+        params: {
+          page_size: "1",
+        },
+        headers,
+      })
+  );
+
+  return response.count ?? null;
+}
+
+export function extractProfileEnabledAt(
+  logPage: CountlessPage<ProfileActivityLog> | null
+): string | null {
+  if (!logPage?.data?.length) {
+    return null;
+  }
+  const createdAt = logPage.data[0]?.created_at;
+  if (!createdAt) {
+    return null;
+  }
+  return new Date(createdAt).toISOString();
+}
diff --git a/components/user/user-page-header/userPageHeaderPrefetch.ts b/components/user/user-page-header/userPageHeaderPrefetch.ts
new file mode 100644
index 0000000000..6042ff5878
--- /dev/null
+++ b/components/user/user-page-header/userPageHeaderPrefetch.ts
@@ -0,0 +1,109 @@
+import { cache } from "react";
+
+import type { ApiIdentity } from "@/generated/models/ApiIdentity";
+import type { CicStatement, ProfileActivityLog } from "@/entities/IProfile";
+import type { CountlessPage } from "@/helpers/Types";
+import { getProfileCicStatements } from "@/helpers/server.helpers";
+import { withServerTiming } from "@/helpers/performance.helpers";
+import {
+  extractProfileEnabledAt,
+  fetchFollowersCount,
+  fetchProfileEnabledLog,
+} from "./userPageHeaderData";
+
+const fetchHeaderStatements = cache(
+  async (
+    normalizedHandleOrWallet: string,
+    headers: Record<string, string>
+  ): Promise<CicStatement[]> =>
+    await withServerTiming(
+      `identity-statements:${normalizedHandleOrWallet}`,
+      async () =>
+        await getProfileCicStatements({
+          handleOrWallet: normalizedHandleOrWallet,
+          headers,
+        })
+    )
+);
+
+const fetchHeaderProfileLog = cache(
+  async (
+    normalizedHandleOrWallet: string,
+    headers: Record<string, string>
+  ): Promise<CountlessPage<ProfileActivityLog> | null> =>
+    await fetchProfileEnabledLog({
+      handleOrWallet: normalizedHandleOrWallet,
+      headers,
+    })
+);
+
+const fetchHeaderFollowersCount = cache(
+  async (
+    profileId: ApiIdentity["id"],
+    headers: Record<string, string>
+  ): Promise<number | null> => {
+    if (!profileId) {
+      return null;
+    }
+    return await fetchFollowersCount({
+      profileId,
+      headers,
+    });
+  }
+);
+
+export type UserPageHeaderPrefetchResult = Readonly<{
+  statements: CicStatement[];
+  profileEnabledAt: string | null;
+  followersCount: number | null;
+}>;
+
+export async function prefetchUserPageHeaderData({
+  profile,
+  headers,
+  handleOrWallet,
+}: {
+  readonly profile: ApiIdentity;
+  readonly headers: Record<string, string>;
+  readonly handleOrWallet: string;
+}): Promise<UserPageHeaderPrefetchResult> {
+  if (!handleOrWallet) {
+    return {
+      statements: [],
+      profileEnabledAt: null,
+      followersCount: null,
+    };
+  }
+
+  const normalizedHandleOrWallet = handleOrWallet.toLowerCase();
+
+  const [statementsResult, profileLogResult, followersResult] =
+    await Promise.allSettled([
+      fetchHeaderStatements(normalizedHandleOrWallet, headers),
+      fetchHeaderProfileLog(normalizedHandleOrWallet, headers),
+      fetchHeaderFollowersCount(profile.id, headers),
+    ]);
+
+  const statements =
+    statementsResult.status === "fulfilled" ? statementsResult.value : [];
+
+  const profileLog =
+    profileLogResult.status === "fulfilled" ? profileLogResult.value : null;
+
+  const profileEnabledAt = extractProfileEnabledAt(profileLog);
+
+  const followersCount =
+    followersResult.status === "fulfilled" ? followersResult.value : null;
+
+  return {
+    statements,
+    profileEnabledAt,
+    followersCount,
+  };
+}
+
+export {
+  fetchHeaderStatements,
+  fetchHeaderProfileLog,
+  fetchHeaderFollowersCount,
+};
diff --git a/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper.tsx b/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper.tsx
index d29112df03..5870f76aec 100644
--- a/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper.tsx
+++ b/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper.tsx
@@ -14,7 +14,6 @@ import { assertUnreachable } from "@/helpers/AllowlistToolHelpers";
 import { Page } from "@/helpers/Types";
 import { commonApiFetch } from "@/services/api/common-api";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
-import { useParams } from "next/navigation";
 import { useEffect, useState } from "react";
 import ProfileRatersTable from "../ProfileRatersTable";
 import ProfileRatersTableWrapperHeader from "./ProfileRatersTableWrapperHeader";
@@ -31,11 +30,16 @@ export interface ProfileRatersParams {
 
 export default function ProfileRatersTableWrapper({
   initialParams,
+  handleOrWallet,
+  initialData,
 }: {
   readonly initialParams: ProfileRatersParams;
+  readonly handleOrWallet?: string;
+  readonly initialData?: Page<RatingWithProfileInfoAndLevel>;
 }) {
-  const params = useParams();
-  const handleOrWallet = (params?.user as string)?.toLowerCase();
+  const normalizedHandle = (
+    handleOrWallet ?? initialParams.handleOrWallet
+  ).toLowerCase();
   const pageSize = initialParams.pageSize;
   const given = initialParams.given;
   const matter = initialParams.matter;
@@ -65,6 +69,8 @@ export default function ProfileRatersTableWrapper({
 
   const type = getType();
 
+  const hasInitialData = !!initialData;
+
   const {
     isLoading,
     isFetching,
@@ -73,7 +79,7 @@ export default function ProfileRatersTableWrapper({
     queryKey: [
       QueryKey.PROFILE_RATERS,
       {
-        handleOrWallet,
+        handleOrWallet: normalizedHandle,
         matter,
         page: `${currentPage}`,
         pageSize: `${pageSize}`,
@@ -84,7 +90,7 @@ export default function ProfileRatersTableWrapper({
     ],
     queryFn: async () =>
       await commonApiFetch<Page<RatingWithProfileInfoAndLevel>>({
-        endpoint: `profiles/${handleOrWallet}/${
+        endpoint: `profiles/${normalizedHandle}/${
           matter === RateMatter.NIC ? "cic" : matter.toLowerCase()
         }/ratings/by-rater`,
         params: {
@@ -95,8 +101,13 @@ export default function ProfileRatersTableWrapper({
           given: given ? "true" : "false",
         },
       }),
-    enabled: !!handleOrWallet,
+    enabled: !!normalizedHandle,
+    initialData,
     placeholderData: keepPreviousData,
+    staleTime: hasInitialData ? 30_000 : 0,
+    refetchOnMount: hasInitialData ? false : undefined,
+    refetchOnWindowFocus: hasInitialData ? false : undefined,
+    refetchOnReconnect: hasInitialData ? false : undefined,
   });
 
   const [totalPages, setTotalPages] = useState<number>(1);
diff --git a/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapperHeader.tsx b/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapperHeader.tsx
index e6e6334419..026698c224 100644
--- a/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapperHeader.tsx
+++ b/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapperHeader.tsx
@@ -1,6 +1,5 @@
-import ProfileName, {
-  ProfileNameType,
-} from "@/components/profile-activity/ProfileName";
+import ProfileName from "@/components/profile-activity/ProfileName";
+import { ProfileNameType } from "@/components/profile-activity/profileName.types";
 import { ProfileRatersTableType } from "@/enums";
 import UserTableHeaderWrapper from "@/components/user/utils/UserTableHeaderWrapper";
 
diff --git a/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.tsx b/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.tsx
index d293b50fe0..5d176d4ba4 100644
--- a/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.tsx
+++ b/components/user/utils/set-up-profile/UserPageSetUpProfileWrapper.tsx
@@ -1,25 +1,41 @@
 "use client";
 
-import { ReactNode, useEffect, useState } from "react";
+import { ReactNode, useEffect, useMemo, useState } from "react";
 
 import UserPageSetUpProfile from "./UserPageSetUpProfile";
 import { useSeizeConnectContext } from "@/components/auth/SeizeConnectContext";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
+import { useIdentity } from "@/hooks/useIdentity";
 
 export default function UserPageSetUpProfileWrapper({
   profile,
   children,
+  handleOrWallet,
 }: {
   readonly profile: ApiIdentity;
   readonly children: ReactNode;
+  readonly handleOrWallet?: string;
 }) {
   const { address } = useSeizeConnectContext();
 
+  const normalizedHandleOrWallet = useMemo(() => {
+    if (handleOrWallet) return handleOrWallet.toLowerCase();
+    if (profile?.handle) return profile.handle.toLowerCase();
+    return profile?.wallets?.[0]?.wallet?.toLowerCase() ?? null;
+  }, [handleOrWallet, profile]);
+
+  const { profile: hydratedProfile } = useIdentity({
+    handleOrWallet: normalizedHandleOrWallet,
+    initialProfile: profile,
+  });
+
+  const resolvedProfile = hydratedProfile ?? profile;
+
   const getShowSetUpProfile = () => {
     if (!address) return false;
-    if (!profile) return false;
-    if (profile.handle) return false;
-    return !!profile.wallets?.find((w) =>
+    if (!resolvedProfile) return false;
+    if (resolvedProfile.handle) return false;
+    return !!resolvedProfile.wallets?.find((w) =>
       [w.wallet.toLowerCase(), w.display?.toLowerCase()].includes(
         address.toLowerCase()
       )
@@ -32,11 +48,11 @@ export default function UserPageSetUpProfileWrapper({
 
   useEffect(
     () => setShowSetUpProfile(getShowSetUpProfile()),
-    [profile, address]
+    [resolvedProfile, address]
   );
 
   if (showSetUpProfile) {
-    return <UserPageSetUpProfile profile={profile} />;
+    return <UserPageSetUpProfile profile={resolvedProfile} />;
   }
   return <>{children}</>;
 }
diff --git a/helpers/performance.helpers.ts b/helpers/performance.helpers.ts
new file mode 100644
index 0000000000..fd889b8b64
--- /dev/null
+++ b/helpers/performance.helpers.ts
@@ -0,0 +1,15 @@
+const formatDuration = (durationMs: number): number =>
+  Number(durationMs.toFixed(2));
+
+export async function withServerTiming<T>(
+  label: string,
+  fn: () => Promise<T>
+): Promise<T> {
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    const duration = formatDuration(performance.now() - start);
+    console.info(`[server-timing] ${label}=${duration}ms`);
+  }
+}
diff --git a/helpers/server.helpers.ts b/helpers/server.helpers.ts
index 246940d8d0..4f376e645e 100644
--- a/helpers/server.helpers.ts
+++ b/helpers/server.helpers.ts
@@ -1,11 +1,15 @@
 import { ActivityLogParamsConverted } from "@/components/profile-activity/ProfileActivityLogs";
-import { ProfileRatersParams } from "@/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper";
-import { ProfileActivityLog } from "@/entities/IProfile";
+import {
+  CicStatement,
+  ProfileActivityLog,
+  RatingWithProfileInfoAndLevel,
+} from "@/entities/IProfile";
 import { SortDirection } from "@/entities/ISort";
 import { ProfileRatersParamsOrderBy, RateMatter } from "@/enums";
 import { ApiIdentity } from "@/generated/models/ApiIdentity";
 import { commonApiFetch } from "@/services/api/common-api";
 import { Page } from "./Types";
+import { ProfileRatersParams } from "@/components/user/utils/raters-table/wrapper/ProfileRatersTableWrapper";
 
 export const getUserProfile = async ({
   user,
@@ -134,3 +138,45 @@ export const getInitialRatersParams = ({
   orderBy: ProfileRatersParamsOrderBy.RATING,
   handleOrWallet,
 });
+
+export const getProfileCicStatements = async ({
+  handleOrWallet,
+  headers,
+}: {
+  handleOrWallet: string;
+  headers: Record<string, string>;
+}): Promise<CicStatement[]> => {
+  return await commonApiFetch<CicStatement[]>({
+    endpoint: `profiles/${handleOrWallet}/cic/statements`,
+    headers,
+  });
+};
+
+export const getProfileCicRatings = async ({
+  handleOrWallet,
+  headers,
+  params,
+}: {
+  handleOrWallet: string;
+  headers: Record<string, string>;
+  params: {
+    page: number;
+    pageSize: number;
+    given: boolean;
+    order: SortDirection;
+    orderBy: ProfileRatersParamsOrderBy;
+  };
+}): Promise<Page<RatingWithProfileInfoAndLevel>> => {
+  const { page, pageSize, given, order, orderBy } = params;
+  return await commonApiFetch<Page<RatingWithProfileInfoAndLevel>>({
+    endpoint: `profiles/${handleOrWallet}/cic/ratings/by-rater`,
+    params: {
+      page: `${page}`,
+      page_size: `${pageSize}`,
+      order,
+      order_by: orderBy.toLowerCase(),
+      given: given ? "true" : "false",
+    },
+    headers,
+  });
+};
diff --git a/hooks/useIdentity.ts b/hooks/useIdentity.ts
index 701891f2a9..059bbeaef4 100644
--- a/hooks/useIdentity.ts
+++ b/hooks/useIdentity.ts
@@ -19,6 +19,8 @@ export function useIdentity({
   handleOrWallet,
   initialProfile,
 }: Readonly<UseIdentityProps>) {
+  const hasInitialProfile =
+    initialProfile !== null && initialProfile !== undefined;
   const { data: profile, isLoading } = useQuery<ApiIdentity>({
     queryKey: [QueryKey.PROFILE, handleOrWallet?.toLowerCase()],
     queryFn: async () =>
@@ -28,6 +30,10 @@ export function useIdentity({
     enabled: !!handleOrWallet,
     initialData: initialProfile ?? undefined,
     retry: 3,
+    staleTime: hasInitialProfile ? 300_000 : 0,
+    refetchOnMount: hasInitialProfile ? false : undefined,
+    refetchOnWindowFocus: hasInitialProfile ? false : undefined,
+    refetchOnReconnect: hasInitialProfile ? false : undefined,
   });
 
   return { profile: profile ?? null, isLoading };