diff --git a/src/authz-module/audit-user/index.test.tsx b/src/authz-module/audit-user/index.test.tsx
new file mode 100644
index 00000000..b0b37cad
--- /dev/null
+++ b/src/authz-module/audit-user/index.test.tsx
@@ -0,0 +1,313 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import { AppContext } from '@edx/frontend-platform/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { ToastManagerProvider } from '@src/authz-module/data/context/ToastManagerContext';
+import AuditUserPage from './index';
+
+jest.mock('@edx/frontend-platform/auth', () => ({
+  getAuthenticatedHttpClient: jest.fn(),
+  configure: jest.fn(), // Add this line
+}));
+
+const mockUser = {
+  username: 'johndoe',
+  email: 'john@example.com',
+  profile_image: { has_image: false },
+};
+const mockAssignments = {
+  count: 1,
+  results: [
+    {
+      id: '1',
+      role: 'library_admin',
+      org: 'Test Org',
+      scope: 'lib:test',
+      permissionCount: 5,
+    },
+  ],
+  next: null,
+  previous: null,
+};
+
+const renderWithRouter = (route = '/audit/johndoe') => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+
+  const mockAppContext = {
+    authenticatedUser: {
+      username: 'testuser',
+      email: 'testuser@example.com',
+    },
+    config: {
+      // @ts-ignore
+      ...process.env,
+    },
+  };
+
+  return render(
+    <AppContext.Provider value={mockAppContext}>
+      <QueryClientProvider client={queryClient}>
+        <IntlProvider locale="en">
+          <ToastManagerProvider>
+            <MemoryRouter initialEntries={[route]}>
+              <Routes>
+                <Route path="/audit/:username" element={<AuditUserPage />} />
+                <Route path="/authz" element={<div>Home Page</div>} />
+              </Routes>
+            </MemoryRouter>
+          </ToastManagerProvider>
+        </IntlProvider>
+      </QueryClientProvider>
+    </AppContext.Provider>,
+  );
+};
+
+describe('AuditUserPage', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  beforeAll(() => {
+  // @ts-ignore
+    global.logError = jest.fn();
+  });
+
+  it('renders user info and table when data is loaded', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('heading', { name: 'johndoe' })).toBeInTheDocument();
+      expect(screen.getByText('john@example.com')).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /assign role/i })).toBeInTheDocument();
+      expect(screen.getByText('Library Admin')).toBeInTheDocument();
+      expect(screen.getByText('Test Org')).toBeInTheDocument();
+      expect(screen.getByText('lib:test')).toBeInTheDocument();
+      expect(screen.getByText('5 permissions available')).toBeInTheDocument();
+    });
+  });
+
+  it('navigates to home if user is not found', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: null })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByText('Home Page')).toBeInTheDocument();
+    });
+  });
+
+  it('allows user to interact with Assign Role button', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /assign role/i })).toBeInTheDocument();
+    });
+
+    const user = userEvent.setup();
+    const button = screen.getByRole('button', { name: /assign role/i });
+    await user.click(button);
+    expect(button).not.toBeInTheDocument();
+  });
+
+  it('renders empty state when user has no assignments', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({
+          data: {
+            count: 0, results: [], next: null, previous: null,
+          },
+        }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('heading', { name: 'johndoe' })).toBeInTheDocument();
+      expect(screen.queryByText('5 permissions available')).not.toBeInTheDocument();
+      expect(screen.getByRole('table')).toBeInTheDocument();
+    });
+  });
+
+  it('renders correct table headers', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByText('Role')).toBeInTheDocument();
+      expect(screen.getByText('Organization')).toBeInTheDocument();
+      expect(screen.getByText('Scope')).toBeInTheDocument();
+      expect(screen.getByText('Permissions')).toBeInTheDocument();
+      expect(screen.getByText('Actions')).toBeInTheDocument();
+    });
+  });
+
+  it('renders the pagination controls when assignments are present', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByText('Showing 1 of 1.')).toBeInTheDocument();
+    });
+  });
+
+  it('renders the breadcrumb navigation with home link', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('link', { name: /roles and permissions management/i })).toBeInTheDocument();
+      expect(screen.getByText(mockUser.username, { selector: 'li[aria-current="page"]' })).toBeInTheDocument();
+    });
+  });
+
+  it('opens and closes the ConfirmDeletionModal when delete is clicked and cancel is pressed', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /delete role action/i })).toBeInTheDocument();
+    });
+
+    const user = userEvent.setup();
+    const deleteButton = screen.getByRole('button', { name: /delete role action/i });
+    await user.click(deleteButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole('dialog')).toBeInTheDocument();
+      expect(screen.getByText(/remove role\?/i)).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument();
+    });
+
+    const cancelButton = screen.getByRole('button', { name: /cancel/i });
+    await user.click(cancelButton);
+
+    await waitFor(() => {
+      expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    });
+  });
+
+  it('calls onSave when confirming deletion in ConfirmDeletionModal', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({ data: mockAssignments }),
+      delete: jest.fn().mockResolvedValue({ data: { errors: [] } }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /delete role action/i })).toBeInTheDocument();
+    });
+
+    const user = userEvent.setup();
+    const deleteButton = screen.getByRole('button', { name: /delete role action/i });
+    await user.click(deleteButton);
+
+    await waitFor(() => {
+      expect(screen.getByRole('dialog')).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /remove/i })).toBeInTheDocument();
+    });
+
+    const removeButton = screen.getByRole('button', { name: /remove/i });
+    await user.click(removeButton);
+
+    await waitFor(() => {
+      expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+      expect(screen.getByText(/role has been successfully removed/i)).toBeInTheDocument();
+    });
+  });
+
+  it('shows the extra warning when rolesCount is 1', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest
+        .fn()
+        .mockResolvedValueOnce({ data: mockUser })
+        .mockResolvedValueOnce({
+          data: {
+            count: 1,
+            results: [
+              {
+                id: '1',
+                role: 'library_admin',
+                org: 'Test Org',
+                scope: 'lib:test',
+                permissionCount: 5,
+              },
+            ],
+            next: null,
+            previous: null,
+          },
+        }),
+    });
+
+    renderWithRouter();
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /delete role action/i })).toBeInTheDocument();
+    });
+
+    const user = userEvent.setup();
+    const deleteButton = screen.getByRole('button', { name: /delete role action/i });
+    await user.click(deleteButton);
+
+    await waitFor(() => {
+      expect(screen.getByText(/this is the user's only role/i)).toBeInTheDocument();
+    });
+  });
+});
diff --git a/src/authz-module/audit-user/index.tsx b/src/authz-module/audit-user/index.tsx
new file mode 100644
index 00000000..d18ffb3d
--- /dev/null
+++ b/src/authz-module/audit-user/index.tsx
@@ -0,0 +1,215 @@
+import React, { useContext, useMemo, useState } from 'react';
+import { useIntl } from '@edx/frontend-platform/i18n';
+import { AppContext } from '@edx/frontend-platform/react';
+import type { AppContextType } from '@edx/frontend-platform/react';
+import debounce from 'lodash.debounce';
+import {
+  Container, DataTable,
+} from '@openedx/paragon';
+import TableFooter from '@src/authz-module/components/TableFooter/TableFooter';
+import { AUTHZ_HOME_PATH, TABLE_DEFAULT_PAGE_SIZE } from '@src/authz-module/constants';
+import AuthZLayout from '@src/authz-module/components/AuthZLayout';
+import { useNavigate, useParams } from 'react-router-dom';
+import { useUserAccount } from '@src/data/hooks';
+import baseMessages from '@src/authz-module/messages';
+import AddRoleButton from '@src/authz-module/components/AddRoleButton';
+import {
+  OrgCell, RoleCell, ScopeCell, PermissionsCell, ViewAllPermissionsCell,
+  createActionsCell,
+} from '@src/authz-module/components/TableCells';
+import { useQuerySettings } from '@src/authz-module/hooks/useQuerySettings';
+import { useRevokeUserRoles, useUserAssignedRoles } from '@src/authz-module/data/hooks';
+import { Role } from 'types';
+import { useToastManager } from '@src/authz-module/data/context/ToastManagerContext';
+import messages from './messages';
+import ConfirmDeletionModal from '../components/ConfirmDeletionModal';
+
+const AuditUserPage = () => {
+  const { formatMessage } = useIntl();
+  const { username } = useParams();
+  const { authenticatedUser } = useContext(AppContext) as AppContextType;
+  const navigate = useNavigate();
+  const [roleToDelete, setRoleToDelete] = useState<Role | null>(null);
+  const [showConfirmDeletionModal, setShowConfirmDeletionModal] = useState(false);
+  const {
+    showToast, showErrorToast, Bold, Br,
+  } = useToastManager();
+  const { mutate: revokeUserRoles, isPending: isRevokingUserRolePending } = useRevokeUserRoles();
+  const { isLoading: isLoadingUser, data: user } = useUserAccount(username ?? '');
+  const { querySettings, handleTableFetch } = useQuerySettings();
+  const { data: { results: userAssignments, count } = { results: [] } } = useUserAssignedRoles(username ?? '', querySettings);
+
+  if (!user && !isLoadingUser) {
+    navigate(AUTHZ_HOME_PATH);
+  }
+  const navLinks = [
+    {
+      label: formatMessage(baseMessages['authz.management.home.nav.link']),
+      to: AUTHZ_HOME_PATH,
+    },
+  ];
+
+  const columns = [
+    {
+      Header: formatMessage(messages['authz.user.table.role.column.header']),
+      accessor: 'role',
+      Cell: RoleCell,
+    },
+    {
+      Header: formatMessage(messages['authz.user.table.organization.column.header']),
+      accessor: 'org',
+      Cell: OrgCell,
+    },
+    {
+      Header: formatMessage(messages['authz.user.table.scope.column.header']),
+      accessor: 'scope',
+      Cell: ScopeCell,
+      disableFilters: true,
+    },
+    {
+      Header: formatMessage(messages['authz.user.table.permissions.column.header']),
+      Cell: PermissionsCell,
+      disableFilters: true,
+      disableSortBy: true,
+    },
+  ];
+  const pageCount = userAssignments?.length ? Math.ceil(userAssignments.length / TABLE_DEFAULT_PAGE_SIZE) : 1;
+
+  const fetchData = useMemo(() => debounce(handleTableFetch, 500), [handleTableFetch]);
+
+  const handleShowConfirmDeletionModal = (role: Role) => {
+    if (isRevokingUserRolePending) { return; }
+
+    setRoleToDelete(role);
+    setShowConfirmDeletionModal(true);
+  };
+
+  const handleCloseConfirmDeletionModal = () => {
+    setRoleToDelete(null);
+    setShowConfirmDeletionModal(false);
+  };
+
+  const handleRevokeUserRole = () => {
+    if (!user || !roleToDelete) { return; }
+
+    const data = {
+      users: user.username,
+      role: roleToDelete.role,
+      scope: roleToDelete.scope,
+    };
+
+    const runRevokeRole = (variables) => {
+      const variablesData = {
+        data: {
+          ...variables.data,
+          querySettings,
+        },
+
+      };
+      revokeUserRoles(variablesData, {
+        onSuccess: (response) => {
+          const { errors } = response;
+
+          if (errors.length) {
+            showToast({
+              type: 'error',
+              message: formatMessage(
+                baseMessages['authz.team.toast.default.error.message'],
+                { Bold, Br },
+              ),
+            });
+            // authzQueryKeys.userRoles(username, querySettings),
+            return;
+          }
+
+          const remainingRolesCount = count ? count - 1 : 0;
+          showToast({
+            message: formatMessage(
+              baseMessages['authz.team.remove.user.toast.success.description'],
+              {
+                role: roleToDelete.name,
+                rolesCount: remainingRolesCount,
+              },
+            ),
+            type: 'success',
+          });
+          handleCloseConfirmDeletionModal();
+        },
+        onError: (error, retryVariables) => {
+          showErrorToast(error, () => runRevokeRole(retryVariables));
+        },
+      });
+    };
+
+    runRevokeRole({ data });
+  };
+
+  const additionalColumns = [
+    {
+      id: 'view_permissions',
+      Header: '',
+      Cell: ViewAllPermissionsCell,
+    },
+    {
+      id: 'action',
+      Header: formatMessage(messages['authz.user.table.action.column.header']),
+      Cell: createActionsCell({
+        onClickDeleteButton: handleShowConfirmDeletionModal,
+        isUserAuthenticatedPage: username === authenticatedUser.username,
+      }),
+    },
+  ];
+
+  return (
+    <div className="authz-module">
+      <ConfirmDeletionModal
+        isOpen={showConfirmDeletionModal}
+        close={handleCloseConfirmDeletionModal}
+        onSave={handleRevokeUserRole}
+        isDeleting={isRevokingUserRolePending}
+        context={{
+          userName: user?.username || '',
+          scope: roleToDelete?.scope || '',
+          role: roleToDelete?.name || '',
+          rolesCount: count || 0,
+        }}
+      />
+      <AuthZLayout
+        context={{
+          id: '',
+          org: '',
+          title: '',
+        }}
+        navLinks={navLinks}
+        activeLabel={username || ''}
+        pageTitle={user?.username || ''}
+        pageSubtitle={user?.email || ''}
+        actions={
+          [
+            <AddRoleButton presetUsername={user?.username} key="add-role-button" />,
+          ]
+        }
+      >
+        <Container className="bg-light-200 p-5">
+          <DataTable
+            isPaginated
+            manualPagination
+            data={userAssignments}
+            fetchData={fetchData}
+            itemCount={userAssignments?.length || 0}
+            pageCount={pageCount}
+            initialState={{ pageSize: TABLE_DEFAULT_PAGE_SIZE }}
+            additionalColumns={additionalColumns}
+            columns={columns}
+          >
+            <DataTable.Table />
+            <TableFooter />
+          </DataTable>
+
+        </Container>
+      </AuthZLayout>
+    </div>
+  );
+};
+
+export default AuditUserPage;
diff --git a/src/authz-module/audit-user/messages.ts b/src/authz-module/audit-user/messages.ts
new file mode 100644
index 00000000..dd3747fe
--- /dev/null
+++ b/src/authz-module/audit-user/messages.ts
@@ -0,0 +1,48 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages(
+  {
+    'authz.user.table.role.column.header': {
+      id: 'authz.user.table.role.column.header',
+      defaultMessage: 'Role',
+      description: 'Header for the role column in the user table',
+    },
+    'authz.user.table.organization.column.header': {
+      id: 'authz.user.table.organization.column.header',
+      defaultMessage: 'Organization',
+      description: 'Header for the organization column in the user table',
+    },
+    'authz.user.table.scope.column.header': {
+      id: 'authz.user.table.scope.column.header',
+      defaultMessage: 'Scope',
+      description: 'Header for the scope column in the user table',
+    },
+    'authz.user.table.permissions.column.header': {
+      id: 'authz.user.table.permissions.column.header',
+      defaultMessage: 'Permissions',
+      description: 'Header for the permissions column in the user table',
+    },
+    'authz.user.table.action.column.header': {
+      id: 'authz.user.table.action.column.header',
+      defaultMessage: 'Actions',
+      description: 'Header for the actions column in the user table',
+    },
+    'authz.user.table.view_all_permissions.link.text': {
+      id: 'authz.user.table.view_all_permissions.link.text',
+      defaultMessage: 'View all permissions',
+      description: 'Text for the link to view all permissions in the user table',
+    },
+    'authz.user.table.delete.action.alt': {
+      id: 'authz.user.table.delete.action.alt',
+      defaultMessage: 'Delete role action',
+      description: 'Alt description for delete button',
+    },
+    'authz.user.table.permissions.available.count': {
+      id: 'authz.user.table.permissions.available.count',
+      defaultMessage: '{count, plural, one {# permission available} other {# permissions available}}',
+      description: 'Text showing the number of permissions available, with proper pluralization',
+    },
+  },
+);
+
+export default messages;
diff --git a/src/authz-module/components/AddRoleButton.test.tsx b/src/authz-module/components/AddRoleButton.test.tsx
new file mode 100644
index 00000000..7765faf4
--- /dev/null
+++ b/src/authz-module/components/AddRoleButton.test.tsx
@@ -0,0 +1,134 @@
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useNavigate } from 'react-router-dom';
+import { initializeMockApp } from '@edx/frontend-platform/testing';
+import { renderWrapper } from '@src/setupTest';
+import AddRoleButton from './AddRoleButton';
+
+// Mock react-router-dom navigation
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useNavigate: jest.fn(),
+}));
+
+describe('AddRoleButton', () => {
+  const mockNavigate = jest.fn();
+
+  beforeAll(() => {
+    initializeMockApp({
+      authenticatedUser: {
+        userId: 1,
+        username: 'testuser',
+        email: 'test@example.com',
+      },
+    });
+  });
+
+  beforeEach(() => {
+    (useNavigate as jest.Mock).mockReturnValue(mockNavigate);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('rendering', () => {
+    it('renders the assign role button with correct text', () => {
+      renderWrapper(<AddRoleButton />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      expect(button).toBeInTheDocument();
+    });
+
+    it('displays the plus icon', () => {
+      renderWrapper(<AddRoleButton />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      expect(button.querySelector('svg')).toBeInTheDocument();
+    });
+
+    it('renders correctly when presetUsername is provided', () => {
+      renderWrapper(<AddRoleButton presetUsername="testuser123" />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      expect(button).toBeInTheDocument();
+    });
+  });
+
+  describe('navigation behavior', () => {
+    it('navigates to assign role page without username when clicked', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<AddRoleButton />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      await user.click(button);
+
+      expect(mockNavigate).toHaveBeenCalledTimes(1);
+      expect(mockNavigate).toHaveBeenCalledWith('/authz/assign-role');
+    });
+
+    it('navigates to assign role page with username query parameter when presetUsername is provided', async () => {
+      const user = userEvent.setup();
+      const presetUsername = 'john.doe';
+      renderWrapper(<AddRoleButton presetUsername={presetUsername} />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      await user.click(button);
+
+      expect(mockNavigate).toHaveBeenCalledTimes(1);
+      expect(mockNavigate).toHaveBeenCalledWith(`/authz/assign-role?username=${presetUsername}`);
+    });
+
+    it('handles special characters in presetUsername correctly', async () => {
+      const user = userEvent.setup();
+      const presetUsername = 'user@example.com';
+      renderWrapper(<AddRoleButton presetUsername={presetUsername} />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      await user.click(button);
+
+      expect(mockNavigate).toHaveBeenCalledTimes(1);
+      expect(mockNavigate).toHaveBeenCalledWith(`/authz/assign-role?username=${presetUsername}`);
+    });
+  });
+
+  describe('user interactions', () => {
+    it('responds to keyboard navigation', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<AddRoleButton />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+
+      await user.tab();
+      expect(button).toHaveFocus();
+
+      await user.keyboard('{Enter}');
+      expect(mockNavigate).toHaveBeenCalledWith('/authz/assign-role');
+    });
+
+    it('responds to spacebar activation', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<AddRoleButton />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+      button.focus();
+
+      await user.keyboard(' ');
+      expect(mockNavigate).toHaveBeenCalledWith('/authz/assign-role');
+    });
+
+    it('handles multiple clicks gracefully', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<AddRoleButton presetUsername="testuser" />);
+
+      const button = screen.getByRole('button', { name: /assign role/i });
+
+      await user.click(button);
+      await user.click(button);
+      await user.click(button);
+
+      expect(mockNavigate).toHaveBeenCalledTimes(3);
+      expect(mockNavigate).toHaveBeenCalledWith('/authz/assign-role?username=testuser');
+    });
+  });
+});
diff --git a/src/authz-module/components/AddRoleButton.tsx b/src/authz-module/components/AddRoleButton.tsx
new file mode 100644
index 00000000..8a44e750
--- /dev/null
+++ b/src/authz-module/components/AddRoleButton.tsx
@@ -0,0 +1,32 @@
+import React from 'react';
+import { useIntl } from '@edx/frontend-platform/i18n';
+import { Button } from '@openedx/paragon';
+import { Plus } from '@openedx/paragon/icons';
+
+import baseMessages from '@src/authz-module/messages';
+import { useNavigate } from 'react-router-dom';
+
+interface AddRoleButtonProps {
+  presetUsername?: string;
+}
+
+const AddRoleButton = ({ presetUsername }: AddRoleButtonProps) => {
+  const intl = useIntl();
+  const navigate = useNavigate();
+
+  const handleClick = () => {
+    const assignRolePath = `/authz/assign-role${presetUsername ? `?username=${presetUsername}` : ''}`;
+    navigate(assignRolePath);
+  };
+
+  return (
+    <Button
+      iconBefore={Plus}
+      onClick={handleClick}
+    >
+      {intl.formatMessage(baseMessages['authz.management.assign.role.title'])}
+    </Button>
+  );
+};
+
+export default AddRoleButton;
diff --git a/src/authz-module/components/AuthZLayout.tsx b/src/authz-module/components/AuthZLayout.tsx
index 9845b90c..06b572cc 100644
--- a/src/authz-module/components/AuthZLayout.tsx
+++ b/src/authz-module/components/AuthZLayout.tsx
@@ -14,9 +14,10 @@ interface AuthZLayoutProps extends AuthZTitleProps {
 const AuthZLayout = ({ children, context, ...props }: AuthZLayoutProps) => (
   <>
     <StudioHeader
-      number={context.id}
-      org={context.org}
-      title={context.title}
+      number={context?.id || null}
+      org={context?.org || null}
+      title={context?.title || null}
+      isHiddenMainMenu
     />
     <AuthZTitle {...props} />
     {children}
diff --git a/src/authz-module/components/AuthZTitle.tsx b/src/authz-module/components/AuthZTitle.tsx
index a169c840..f17c7bf4 100644
--- a/src/authz-module/components/AuthZTitle.tsx
+++ b/src/authz-module/components/AuthZTitle.tsx
@@ -50,11 +50,11 @@ const AuthZTitle = ({
       />
       <Row className="mt-4">
         <Col xs={12} md={7} className="mb-4">
-          <div className="d-flex align-items-center">
+          <div className="d-flex align-items-center flex-column-sm">
             <h2 className="text-primary mb-0">{pageTitle}</h2>
             {typeof pageSubtitle === 'string'
-              ? <><hr className="mx-lg-3" /><h3 className="mb-0 py-2 font-weight-light text-gray-700">{pageSubtitle}</h3></>
-              : <><hr className="mx-lg-3" /> <div className="mb-0">{pageSubtitle}</div></>}
+              ? <> { pageSubtitle !== '' && <hr className="mx-lg-3" /> }<h3 className="mb-0 py-2 font-weight-light text-gray-700">{pageSubtitle}</h3></>
+              : <>{ pageSubtitle !== '' && <hr className="mx-lg-3" /> } <div className="mb-0">{pageSubtitle}</div></>}
 
           </div>
         </Col>
diff --git a/src/authz-module/components/ConfirmDeletionModal.tsx b/src/authz-module/components/ConfirmDeletionModal.tsx
new file mode 100644
index 00000000..152082ca
--- /dev/null
+++ b/src/authz-module/components/ConfirmDeletionModal.tsx
@@ -0,0 +1,73 @@
+import {
+  ActionRow, AlertModal, Icon, ModalDialog, Stack,
+  StatefulButton,
+} from '@openedx/paragon';
+import { useIntl } from '@edx/frontend-platform/i18n';
+
+import { SpinnerSimple } from '@openedx/paragon/icons';
+import messages from './messages';
+
+interface ConfirmDeletionModalProps {
+  isOpen: boolean;
+  close: () => void;
+  onSave: () => void;
+  isDeleting?: boolean;
+  context: {
+    userName: string;
+    scope: string;
+    role: string;
+    rolesCount: number;
+  }
+}
+
+const ConfirmDeletionModal = ({
+  isOpen, close, onSave, isDeleting, context,
+}: ConfirmDeletionModalProps) => {
+  const intl = useIntl();
+  return (
+    <AlertModal
+      title={intl.formatMessage(messages['authz.team.remove.user.modal.title'])}
+      isOpen={isOpen}
+      onClose={close}
+      size="lg"
+      footerNode={(
+        <ActionRow>
+          <ModalDialog.CloseButton variant="tertiary">
+            {intl.formatMessage(messages['authz.manage.cancel.button'])}
+          </ModalDialog.CloseButton>
+          <StatefulButton
+            className="px-4"
+            variant="danger"
+            labels={{
+              default: intl.formatMessage(messages['authz.manage.remove.button']),
+              pending: intl.formatMessage(messages['authz.manage.removing.button']),
+            }}
+            icons={{
+              pending: <Icon src={SpinnerSimple} />,
+            }}
+            state={isDeleting ? 'pending' : 'default'}
+            onClick={() => onSave()}
+            disabledStates={['pending']}
+          />
+        </ActionRow>
+      )}
+      isOverflowVisible={false}
+    >
+      <Stack gap={3}>
+        <p>{intl.formatMessage(messages['authz.team.remove.user.modal.body.1'], {
+          userName: context.userName,
+          scope: context.scope,
+          role: context.role,
+        })}
+        </p>
+        {context.rolesCount === 1 && (
+        <p>{intl.formatMessage(messages['authz.team.remove.user.modal.body.2'])}</p>
+        )}
+        <p>{intl.formatMessage(messages['authz.team.remove.user.modal.body.3'])}</p>
+      </Stack>
+
+    </AlertModal>
+  );
+};
+
+export default ConfirmDeletionModal;
diff --git a/src/authz-module/components/TableCells.test.tsx b/src/authz-module/components/TableCells.test.tsx
new file mode 100644
index 00000000..8b972ca2
--- /dev/null
+++ b/src/authz-module/components/TableCells.test.tsx
@@ -0,0 +1,363 @@
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { initializeMockApp } from '@edx/frontend-platform/testing';
+import { renderWrapper } from '@src/setupTest';
+import {
+  RoleCell,
+  OrgCell,
+  ScopeCell,
+  PermissionsCell,
+  ViewAllPermissionsCell,
+  createActionsCell,
+} from './TableCells';
+
+// TODO: remove console.log mocks and implement actual logic for these cells, then update tests accordingly
+// Mock console.log for TODO functions
+jest.spyOn(console, 'log').mockImplementation(() => {});
+
+describe('TableCells Components', () => {
+  beforeAll(() => {
+    initializeMockApp({
+      authenticatedUser: {
+        userId: 1,
+        username: 'testuser',
+        mail: 'test@example.com',
+      },
+    });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('RoleCell', () => {
+    const mockCell = {
+      getCellProps: jest.fn(() => ({ 'data-testid': 'role-cell' })),
+    };
+
+    it('renders the role label for a mapped role', () => {
+      const props = {
+        value: 'library_admin',
+        cell: mockCell,
+        row: {
+          original: {
+            role: 'library_admin', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'role' },
+      };
+
+      renderWrapper(<RoleCell {...props} />);
+
+      expect(screen.getByText('Library Admin')).toBeInTheDocument();
+      expect(mockCell.getCellProps).toHaveBeenCalledWith({ 'data-role': 'Library Admin' });
+    });
+
+    it('renders empty string for unmapped role', () => {
+      const props = {
+        value: 'unknown_role',
+        cell: mockCell,
+        row: {
+          original: {
+            role: 'unknown_role', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'role' },
+      };
+
+      renderWrapper(<RoleCell {...props} />);
+
+      const cellElement = screen.getByTestId('role-cell');
+      expect(cellElement).toHaveTextContent('');
+      expect(mockCell.getCellProps).toHaveBeenCalledWith({ 'data-role': '' });
+    });
+
+    it('applies cell props correctly', () => {
+      const props = {
+        value: 'course_staff',
+        cell: mockCell,
+        row: {
+          original: {
+            role: 'course_staff', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'role' },
+      };
+
+      renderWrapper(<RoleCell {...props} />);
+
+      expect(screen.getByText('Course Staff')).toBeInTheDocument();
+      expect(mockCell.getCellProps).toHaveBeenCalledWith({ 'data-role': 'Course Staff' });
+    });
+  });
+
+  describe('OrgCell', () => {
+    it('displays "All Organizations" for Django superuser role', () => {
+      const props = {
+        value: 'Test Org',
+        row: {
+          original: {
+            role: 'django.superuser', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'org' },
+      };
+
+      renderWrapper(<OrgCell {...props} />);
+
+      expect(screen.getByText('All Organizations')).toBeInTheDocument();
+      expect(screen.queryByText('Test Org')).not.toBeInTheDocument();
+    });
+
+    it('displays "All Organizations" for Django global staff role', () => {
+      const props = {
+        value: 'Test Org',
+        row: {
+          original: {
+            role: 'django.globalstaff', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'org' },
+      };
+
+      renderWrapper(<OrgCell {...props} />);
+
+      expect(screen.getByText('All Organizations')).toBeInTheDocument();
+      expect(screen.queryByText('Test Org')).not.toBeInTheDocument();
+    });
+
+    it('displays the actual org value for non-Django roles', () => {
+      const props = {
+        value: 'Test Organization',
+        row: {
+          original: {
+            role: 'library_admin', org: 'Test Organization', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'org' },
+      };
+
+      renderWrapper(<OrgCell {...props} />);
+
+      expect(screen.getByText('Test Organization')).toBeInTheDocument();
+      expect(screen.queryByText('All Organizations')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('ScopeCell', () => {
+    it('displays "Global" for Django superuser role', () => {
+      const props = {
+        value: 'library',
+        row: {
+          original: {
+            role: 'django.superuser', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'scope' },
+      };
+
+      renderWrapper(<ScopeCell {...props} />);
+
+      expect(screen.getByText('Global')).toBeInTheDocument();
+      expect(screen.queryByText('library')).not.toBeInTheDocument();
+    });
+
+    it('displays "Global" for Django global staff role', () => {
+      const props = {
+        value: 'course',
+        row: {
+          original: {
+            role: 'django.globalstaff', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'scope' },
+      };
+
+      renderWrapper(<ScopeCell {...props} />);
+
+      expect(screen.getByText('Global')).toBeInTheDocument();
+      expect(screen.queryByText('course')).not.toBeInTheDocument();
+    });
+
+    it('displays the actual scope value for non-Django roles', () => {
+      const props = {
+        value: 'Course Scope',
+        row: {
+          original: {
+            role: 'course_admin', org: 'Test Org', scope: 'Course Scope', permissionCount: 1,
+          },
+        },
+        column: { id: 'scope' },
+      };
+
+      renderWrapper(<ScopeCell {...props} />);
+
+      expect(screen.getByText('Course Scope')).toBeInTheDocument();
+      expect(screen.queryByText('Global')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('PermissionsCell', () => {
+    it('displays "Total Access" for Django superuser role', () => {
+      const props = {
+        row: {
+          original: {
+            role: 'django.superuser',
+            org: 'Test Org',
+            scope: 'Test Scope',
+            permissionCount: 10,
+          },
+        },
+        column: { id: 'permissions' },
+      };
+
+      renderWrapper(<PermissionsCell {...props} />);
+
+      expect(screen.getByText('Total Access')).toBeInTheDocument();
+    });
+
+    it('displays "Partial Access" for Django global staff role', () => {
+      const props = {
+        row: {
+          original: {
+            role: 'django.globalstaff',
+            permissionCount: 5,
+            org: 'Test Org',
+            scope: 'Test Scope',
+          },
+        },
+        column: { id: 'permissions' },
+      };
+
+      renderWrapper(<PermissionsCell {...props} />);
+
+      expect(screen.getByText('Partial Access')).toBeInTheDocument();
+    });
+
+    it('displays permission count for non-Django roles', () => {
+      const props = {
+        row: {
+          original: {
+            role: 'library_admin',
+            permissionCount: 3,
+            org: 'Test Org',
+            scope: 'Test Scope',
+          },
+        },
+        column: { id: 'permissions' },
+      };
+
+      renderWrapper(<PermissionsCell {...props} />);
+
+      expect(screen.getByText('3 permissions available')).toBeInTheDocument();
+    });
+  });
+
+  describe('createActionsCell', () => {
+    const mockOnClickDeleteButton = jest.fn();
+    const baseRow = {
+      original: {
+        role: 'library_admin',
+        org: 'Test Org',
+        scope: 'Test Scope',
+        permissionCount: 1,
+      },
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('renders a delete button and calls onClickDeleteButton when clicked', async () => {
+      const user = userEvent.setup();
+      const CustomActionsCell = createActionsCell({
+        onClickDeleteButton: mockOnClickDeleteButton,
+        isUserAuthenticatedPage: false,
+      });
+      renderWrapper(<CustomActionsCell row={baseRow} column={{ id: 'actions' }} />);
+
+      const deleteButton = screen.getByRole('button', { name: /delete role action/i });
+      expect(deleteButton).toBeInTheDocument();
+
+      await user.click(deleteButton);
+      expect(mockOnClickDeleteButton).toHaveBeenCalledWith({ role: 'library_admin', scope: 'Test Scope' });
+    });
+
+    it('renders a disabled button for admin roles when isUserAuthenticatedPage is true', () => {
+      const adminRow = {
+        original: {
+          role: 'course_admin',
+          org: 'Test Org',
+          scope: 'Test Scope',
+          permissionCount: 1,
+        },
+      };
+      const CustomActionsCell = createActionsCell({
+        onClickDeleteButton: mockOnClickDeleteButton,
+        isUserAuthenticatedPage: true,
+      });
+      renderWrapper(<CustomActionsCell row={adminRow} column={{ id: 'actions' }} />);
+
+      const button = screen.getByRole('button', { name: /delete role action/i });
+      expect(button).toBeDisabled();
+    });
+
+    it('renders info icon with tooltip for Django managed roles', async () => {
+      const djangoRow = {
+        original: {
+          role: 'django.superuser',
+          org: 'Test Org',
+          scope: 'Test Scope',
+          permissionCount: 1,
+        },
+      };
+      const user = userEvent.setup();
+      const CustomActionsCell = createActionsCell({
+        onClickDeleteButton: mockOnClickDeleteButton,
+        isUserAuthenticatedPage: true,
+      });
+      renderWrapper(<CustomActionsCell row={djangoRow} column={{ id: 'actions' }} />);
+
+      const infoIcon = screen.getByRole('img', { hidden: true });
+      expect(infoIcon).toBeInTheDocument();
+      await user.hover(infoIcon);
+      expect(screen.getByText(/Please go to Django Admin to manage it/i)).toBeInTheDocument();
+    });
+  });
+
+  describe('ViewAllPermissionsCell', () => {
+    const mockRow = {
+      original: {
+        role: 'library_admin', id: '123', org: 'Test Org', scope: 'Test Scope', permissionCount: 1,
+      },
+    };
+
+    it('renders a view more link', () => {
+      const props = {
+        row: mockRow,
+        column: { id: 'viewMore' },
+      };
+
+      renderWrapper(<ViewAllPermissionsCell {...props} />);
+
+      expect(screen.getByText('View all permissions')).toBeInTheDocument();
+    });
+
+    it('calls onClick handler when view more link is clicked', async () => {
+      const user = userEvent.setup();
+      const props = {
+        row: mockRow,
+        column: { id: 'viewMore' },
+      };
+
+      renderWrapper(<ViewAllPermissionsCell {...props} />);
+
+      const viewMoreButton = screen.getByText('View all permissions');
+      await user.click(viewMoreButton);
+
+      // TODO: replace console.log with actual view more logic and update this test accordingly
+      // eslint-disable-next-line no-console
+      expect(console.log).toHaveBeenCalledWith('View more clicked for row:', mockRow);
+    });
+  });
+});
diff --git a/src/authz-module/components/TableCells.tsx b/src/authz-module/components/TableCells.tsx
new file mode 100644
index 00000000..4560f923
--- /dev/null
+++ b/src/authz-module/components/TableCells.tsx
@@ -0,0 +1,138 @@
+import { useIntl } from '@edx/frontend-platform/i18n';
+import { Role, TableCellValue, UserRole } from '@src/types';
+import { ADMIN_ROLES, DJANGO_MANAGED_ROLES, MAP_ROLE_KEY_TO_LABEL } from '@src/authz-module/constants';
+import {
+  Icon, IconButton, OverlayTrigger, Tooltip,
+} from '@openedx/paragon';
+import { Delete, ExpandMore, Info } from '@openedx/paragon/icons';
+import messages from './messages';
+import ViewMoreLink from './ViewMoreLink';
+
+type CellProps = TableCellValue<UserRole>;
+type CellPropsWithValue = CellProps & {
+  value: string;
+};
+type ExtendedCellProps = CellPropsWithValue & {
+  cell: {
+    getCellProps: (props?: Record<string, string>) => Record<string, string>;
+  };
+};
+type ActionsCellProps = CellProps & {
+  onClickDeleteButton: (role: Role) => void;
+  isUserAuthenticatedPage: boolean;
+};
+
+const RoleCell = ({ value, cell }: ExtendedCellProps) => (
+  <td {...cell.getCellProps({ 'data-role': MAP_ROLE_KEY_TO_LABEL[value] || '' })}>
+    {MAP_ROLE_KEY_TO_LABEL[value] || ''}
+  </td>
+);
+
+const OrgCell = ({ value, row }: CellPropsWithValue) => {
+  const { formatMessage } = useIntl();
+  return (
+    <td>
+      {DJANGO_MANAGED_ROLES.includes(row.original.role) ? formatMessage(messages['authz.user.table.org.all.organizations.label']) : value}
+    </td>
+  );
+};
+
+const ScopeCell = ({ value, row }: CellPropsWithValue) => {
+  const { formatMessage } = useIntl();
+  const isDjangoRole = DJANGO_MANAGED_ROLES.includes(row.original.role);
+  return (
+    <td>
+      {isDjangoRole ? formatMessage(messages['authz.user.table.scope.global.label']) : value}
+    </td>
+  );
+};
+
+const PermissionsCell = ({ row }: CellProps) => {
+  const { formatMessage } = useIntl();
+  const { role, permissionCount: count } = row.original;
+  const isDjangoRole = DJANGO_MANAGED_ROLES.includes(role);
+  return (
+    <span>
+      { isDjangoRole
+        ? formatMessage(
+          messages['authz.user.table.permissions.access.label'],
+          { accessType: role === 'django.superuser' ? 'total' : 'partial' },
+        )
+        : formatMessage(messages['authz.user.table.permissions.available.count'], { count })}
+    </span>
+  );
+};
+
+const ViewAllPermissionsCell = ({ row }: CellProps) => {
+  const { formatMessage } = useIntl();
+  return (
+    <ViewMoreLink
+      label={formatMessage(messages['authz.user.table.view_all_permissions.link.text'])}
+      // TODO: Implement view more functionality
+      // eslint-disable-next-line no-console
+      onClick={() => console.log('View more clicked for row:', row)}
+      iconSrc={ExpandMore}
+    />
+  );
+};
+
+const ActionsCell = ({ row, onClickDeleteButton, isUserAuthenticatedPage }: ActionsCellProps) => {
+  const { formatMessage } = useIntl();
+  const { role } = row.original;
+
+  const handleDelete = () => {
+    const roleToDelete = {
+      role,
+      scope: row.original.scope,
+    } as Role;
+    onClickDeleteButton(roleToDelete);
+  };
+
+  if (DJANGO_MANAGED_ROLES.includes(role)) {
+    return (
+      <OverlayTrigger
+        placement="left"
+        overlay={(
+          <Tooltip variant="light" id="tooltip-left">
+            {formatMessage(messages['authz.user.table.delete.action.djangorole.tooltip'])}
+          </Tooltip>
+      )}
+      >
+        <Icon
+          className="mx-2 pl-1"
+          src={Info}
+        />
+      </OverlayTrigger>
+    );
+  }
+
+  if (ADMIN_ROLES.includes(role) && isUserAuthenticatedPage) {
+    return (
+      <IconButton
+        // @ts-ignore
+        disabled
+        isActive={false}
+        variant="light"
+        alt={formatMessage(messages['authz.user.table.delete.action.alt'])}
+        src={Delete}
+      />
+    );
+  }
+
+  return (
+    <IconButton variant="danger" onClick={handleDelete} alt={formatMessage(messages['authz.user.table.delete.action.alt'])} src={Delete} />
+  );
+};
+
+const createActionsCell = (extraProps) => function customActionsCell(cellProps) {
+  return <ActionsCell {...cellProps} {...extraProps} />;
+};
+
+export {
+  RoleCell,
+  OrgCell,
+  ScopeCell,
+  PermissionsCell,
+  ViewAllPermissionsCell,
+  createActionsCell,
+};
diff --git a/src/authz-module/components/TableFooter/TableFooter.test.tsx b/src/authz-module/components/TableFooter/TableFooter.test.tsx
new file mode 100644
index 00000000..b03f4efe
--- /dev/null
+++ b/src/authz-module/components/TableFooter/TableFooter.test.tsx
@@ -0,0 +1,195 @@
+import React from 'react';
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { DataTableContext } from '@openedx/paragon';
+import { initializeMockApp } from '@edx/frontend-platform/testing';
+import { renderWrapper } from '@src/setupTest';
+import Footer from './TableFooter';
+
+describe('TableFooter', () => {
+  const mockGotoPage = jest.fn();
+
+  const defaultDataTableContext = {
+    pageCount: 5,
+    gotoPage: mockGotoPage,
+    state: {
+      pageIndex: 0,
+      pageSize: 10,
+    },
+    itemCount: 42,
+    rows: [
+      { id: 1, name: 'Item 1' },
+      { id: 2, name: 'Item 2' },
+      { id: 3, name: 'Item 3' },
+    ],
+  };
+
+  const renderFooter = (contextOverrides = {}) => {
+    const contextValue = {
+      ...defaultDataTableContext,
+      ...contextOverrides,
+    };
+
+    return renderWrapper(
+      <DataTableContext.Provider value={contextValue}>
+        <Footer />
+      </DataTableContext.Provider>,
+    );
+  };
+
+  beforeAll(() => {
+    initializeMockApp({
+      authenticatedUser: {
+        userId: 1,
+        username: 'testuser',
+        email: 'test@example.com',
+      },
+    });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('pagination text display', () => {
+    it('displays correct showing text with current page items', () => {
+      renderFooter();
+
+      expect(screen.getByText('Showing 3 of 42.')).toBeInTheDocument();
+    });
+
+    it('displays showing text with different row count', () => {
+      const moreRows = [
+        ...defaultDataTableContext.rows,
+        { id: 4, name: 'Item 4' },
+        { id: 5, name: 'Item 5' },
+      ];
+
+      renderFooter({
+        rows: moreRows,
+        itemCount: 100,
+      });
+
+      expect(screen.getByText('Showing 5 of 100.')).toBeInTheDocument();
+    });
+
+    it('displays showing text when on last page with fewer items', () => {
+      renderFooter({
+        state: {
+          pageIndex: 4,
+          pageSize: 10,
+        },
+        rows: [{ id: 41, name: 'Item 41' }, { id: 42, name: 'Item 42' }],
+        itemCount: 42,
+      });
+
+      expect(screen.getByText('Showing 2 of 42.')).toBeInTheDocument();
+    });
+  });
+
+  describe('pagination controls', () => {
+    it('displays pagination with correct current page', () => {
+      renderFooter();
+
+      const pagination = screen.getByRole('navigation');
+      expect(pagination).toBeInTheDocument();
+
+      const currentPageButton = screen.getByRole('button', { name: '1 of 5' });
+      expect(currentPageButton).toBeInTheDocument();
+    });
+
+    it('navigates to different page when next button is clicked', async () => {
+      const user = userEvent.setup();
+      renderFooter();
+
+      const page3Button = screen.getByRole('button', { name: 'Next, Page 2' });
+      await user.click(page3Button);
+
+      expect(mockGotoPage).toHaveBeenCalledTimes(1);
+    });
+
+    it('shows correct current page when on different page', () => {
+      renderFooter({
+        state: {
+          pageIndex: 2,
+          pageSize: 10,
+        },
+      });
+
+      const currentPageButton = screen.getByRole('button', { name: '3 of 5' });
+      expect(currentPageButton).toBeInTheDocument();
+    });
+  });
+
+  describe('user interactions', () => {
+    it('handles keyboard navigation on pagination', async () => {
+      const user = userEvent.setup();
+      renderFooter();
+
+      // Tab to the next page button and activate with Enter
+      const nextPageButton = screen.getByRole('button', { name: 'Next, Page 2' });
+      nextPageButton.focus();
+      await user.keyboard('{Enter}');
+
+      expect(mockGotoPage).toHaveBeenCalledWith(1);
+    });
+
+    it('handles space key activation on pagination buttons', async () => {
+      const user = userEvent.setup();
+      renderFooter();
+
+      const nextPageButton = screen.getByRole('button', { name: 'Next, Page 2' });
+      nextPageButton.focus();
+      await user.keyboard(' ');
+
+      expect(mockGotoPage).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles single page scenario', () => {
+      renderFooter({
+        pageCount: 1,
+        state: {
+          pageIndex: 0,
+          pageSize: 10,
+        },
+        itemCount: 3,
+      });
+
+      expect(screen.getByText('Showing 3 of 3.')).toBeInTheDocument();
+
+      const page1Button = screen.queryByRole('button', { name: /1 of 1/ });
+      expect(page1Button).not.toBeInTheDocument();
+    });
+
+    it('handles empty results', () => {
+      renderFooter({
+        rows: [],
+        itemCount: 0,
+        pageCount: 1,
+        state: {
+          pageIndex: 0,
+          pageSize: 10,
+        },
+      });
+
+      expect(screen.getByText('Showing 0 of 0.')).toBeInTheDocument();
+    });
+
+    it('handles large page counts correctly', () => {
+      renderFooter({
+        pageCount: 10,
+        state: {
+          pageIndex: 5,
+          pageSize: 10,
+        },
+        itemCount: 95,
+      });
+
+      const currentPageButton = screen.getByRole('button', { name: '6 of 10' });
+      expect(currentPageButton).toBeInTheDocument();
+      expect(screen.getByText('Showing 3 of 95.')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/src/authz-module/components/TableFooter/TableFooter.tsx b/src/authz-module/components/TableFooter/TableFooter.tsx
new file mode 100644
index 00000000..26b3a974
--- /dev/null
+++ b/src/authz-module/components/TableFooter/TableFooter.tsx
@@ -0,0 +1,28 @@
+import React, { useContext } from 'react';
+import { useIntl } from '@edx/frontend-platform/i18n';
+import { DataTableContext, Pagination, TableFooter } from '@openedx/paragon';
+import messages from '../messages';
+
+const Footer = () => {
+  const { formatMessage } = useIntl();
+  const {
+    pageCount, gotoPage, state, itemCount, rows,
+  // @ts-ignore-next-line - Paragon's DataTableContext is not typed
+  } = useContext<DataTableContext>(DataTableContext);
+  const { pageIndex } = state;
+  return (
+    <TableFooter>
+      <span>
+        {formatMessage(messages['authz.table.footer.items.showing.text'], { pageSize: rows.length, itemCount })}
+      </span>
+      <Pagination
+        variant="reduced"
+        currentPage={pageIndex + 1}
+        pageCount={pageCount}
+        onPageSelect={(pageNum) => gotoPage(pageNum - 1)}
+      />
+    </TableFooter>
+  );
+};
+
+export default Footer;
diff --git a/src/authz-module/components/ViewMoreLink.test.tsx b/src/authz-module/components/ViewMoreLink.test.tsx
new file mode 100644
index 00000000..e687515c
--- /dev/null
+++ b/src/authz-module/components/ViewMoreLink.test.tsx
@@ -0,0 +1,77 @@
+import { screen } from '@testing-library/react';
+import { renderWrapper } from '@src/setupTest';
+import userEvent from '@testing-library/user-event';
+import { ExpandMore } from '@openedx/paragon/icons';
+import ViewMoreLink from './ViewMoreLink';
+
+describe('ViewMoreLink', () => {
+  const mockOnClick = jest.fn();
+  const defaultProps = {
+    label: 'View more details',
+    onClick: mockOnClick,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('rendering', () => {
+    it('renders the link with the provided label', () => {
+      renderWrapper(<ViewMoreLink {...defaultProps} />);
+
+      expect(screen.getByText('View more details')).toBeInTheDocument();
+    });
+
+    it('renders without an icon when iconSrc is not provided', () => {
+      renderWrapper(<ViewMoreLink {...defaultProps} />);
+
+      const link = screen.getByText('View more details');
+      expect(link).toBeInTheDocument();
+      // The icon should not be present when iconSrc is not provided
+      expect(link.querySelector('svg')).not.toBeInTheDocument();
+    });
+
+    it('renders with an icon when iconSrc is provided', () => {
+      renderWrapper(<ViewMoreLink {...defaultProps} iconSrc={ExpandMore} />);
+
+      const link = screen.getByText('View more details');
+      expect(link).toBeInTheDocument();
+      // The icon should be present when iconSrc is provided
+      expect(link.querySelector('svg')).toBeInTheDocument();
+    });
+  });
+
+  describe('user interactions', () => {
+    it('calls onClick handler when user clicks the link', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<ViewMoreLink {...defaultProps} />);
+
+      const link = screen.getByText('View more details');
+      await user.click(link);
+
+      expect(mockOnClick).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls onClick handler when user clicks the link with an icon', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<ViewMoreLink {...defaultProps} iconSrc={ExpandMore} />);
+
+      const link = screen.getByText('View more details');
+      await user.click(link);
+
+      expect(mockOnClick).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles multiple clicks correctly', async () => {
+      const user = userEvent.setup();
+      renderWrapper(<ViewMoreLink {...defaultProps} />);
+
+      const link = screen.getByText('View more details');
+      await user.click(link);
+      await user.click(link);
+      await user.click(link);
+
+      expect(mockOnClick).toHaveBeenCalledTimes(3);
+    });
+  });
+});
diff --git a/src/authz-module/components/ViewMoreLink.tsx b/src/authz-module/components/ViewMoreLink.tsx
new file mode 100644
index 00000000..61820cbb
--- /dev/null
+++ b/src/authz-module/components/ViewMoreLink.tsx
@@ -0,0 +1,27 @@
+import React from 'react';
+import { Hyperlink, Icon } from '@openedx/paragon';
+
+interface ViewMoreLinkProps {
+  label: string;
+  onClick: () => void;
+  iconSrc?: React.ComponentType | undefined;
+}
+
+const ViewMoreLink = ({ label, onClick, iconSrc }: ViewMoreLinkProps) => (
+  <Hyperlink
+    destination={undefined}
+    onClick={e => {
+      e.preventDefault();
+      onClick();
+    }}
+  >
+    {label}
+    {iconSrc && (
+      <Icon
+        src={iconSrc}
+      />
+    )}
+  </Hyperlink>
+);
+
+export default ViewMoreLink;
diff --git a/src/authz-module/components/messages.ts b/src/authz-module/components/messages.ts
index 707dde7c..d2fec871 100644
--- a/src/authz-module/components/messages.ts
+++ b/src/authz-module/components/messages.ts
@@ -21,6 +21,81 @@ const messages = defineMessages({
     defaultMessage: 'Scroll to top',
     description: 'Alt text for the scroll to top anchor button',
   },
+  'authz.table.footer.items.showing.text': {
+    id: 'authz.table.footer.items.showing.text',
+    defaultMessage: 'Showing {pageSize} of {itemCount}.',
+    description: 'Text in the table footer indicating how many items are being shown out of the total count.',
+  },
+  'authz.user.table.org.all.organizations.label': {
+    id: 'authz.user.table.org.all.organizations.label',
+    defaultMessage: 'All Organizations',
+    description: 'Label for the "All Organizations" message on the user assignments table when a user has a django managed role assigned.',
+  },
+  'authz.user.table.scope.global.label': {
+    id: 'authz.user.table.scope.global.label',
+    defaultMessage: 'Global',
+    description: 'Label for the "Global" scope in the user assignments table when a user has a django managed role assigned.',
+  },
+  'authz.user.table.permissions.access.label': {
+    id: 'authz.user.table.permissions.access.label',
+    defaultMessage: '{accessType, select, total {Total Access} partial {Partial Access} other {No Access}}',
+    description: 'Label for the permissions access level in the user assignments table, can be Total or Partial.',
+  },
+  'authz.user.table.permissions.available.count': {
+    id: 'authz.user.table.permissions.available.count',
+    defaultMessage: '{count, plural, one {# permission available} other {# permissions available}}',
+    description: 'Text showing the number of permissions available, with proper pluralization',
+  },
+  'authz.user.table.delete.action.alt': {
+    id: 'authz.user.table.delete.action.alt',
+    defaultMessage: 'Delete role action',
+    description: 'Alt description for delete button',
+  },
+  'authz.user.table.view_all_permissions.link.text': {
+    id: 'authz.user.table.view_all_permissions.link.text',
+    defaultMessage: 'View all permissions',
+    description: 'Text for the link to view all permissions in the user table',
+  },
+  'authz.team.remove.user.modal.title': {
+    id: 'authz.team.remove.user.modal.title',
+    defaultMessage: 'Remove role?',
+    description: 'AuthZ team management remove user modal title',
+  },
+  'authz.manage.cancel.button': {
+    id: 'authz.manage.cancel.button',
+    defaultMessage: 'Cancel',
+    description: 'AuthZ cancel button title',
+  },
+  'authz.manage.remove.button': {
+    id: 'authz.manage.remove.button',
+    defaultMessage: 'Remove',
+    description: 'AuthZ remove button title',
+  },
+  'authz.manage.removing.button': {
+    id: 'authz.manage.removing.button',
+    defaultMessage: 'Removing...',
+    description: 'AuthZ removing button title',
+  },
+  'authz.team.remove.user.modal.body.1': {
+    id: 'authz.team.remove.user.modal.body.1',
+    defaultMessage: 'Are you sure you want to remove the {role} role from the user “{userName}” in the scope {scope}?',
+    description: 'AuthZ team management remove user modal body',
+  },
+  'authz.team.remove.user.modal.body.2': {
+    id: 'authz.team.remove.user.modal.body.2',
+    defaultMessage: "This is the user's only role in this scope. Removing it will revoke their access completely, and they will no longer appear in the scope's member list.",
+    description: 'AuthZ team management remove user modal body',
+  },
+  'authz.team.remove.user.modal.body.3': {
+    id: 'authz.team.remove.user.modal.body.3',
+    defaultMessage: 'Are you sure you want to proceed?',
+    description: 'AuthZ team management remove user modal body',
+  },
+  'authz.user.table.delete.action.djangorole.tooltip': {
+    id: 'authz.user.table.delete.action.djangorole.tooltip',
+    defaultMessage: 'You can’t remove this role here. Please go to Django Admin to manage it.',
+    description: 'Tooltip for delete button when hovering over Django roles',
+  },
 });
 
 export default messages;
diff --git a/src/authz-module/constants.ts b/src/authz-module/constants.ts
index 3256bc2c..7804a046 100644
--- a/src/authz-module/constants.ts
+++ b/src/authz-module/constants.ts
@@ -1,6 +1,113 @@
+import { PermissionMetadata, ResourceMetadata, RoleMetadata } from 'types';
+
+export const CONTENT_LIBRARY_PERMISSIONS = {
+  DELETE_LIBRARY: 'content_libraries.delete_library',
+  MANAGE_LIBRARY_TAGS: 'content_libraries.manage_library_tags',
+  VIEW_LIBRARY: 'content_libraries.view_library',
+
+  EDIT_LIBRARY_CONTENT: 'content_libraries.edit_library_content',
+  PUBLISH_LIBRARY_CONTENT: 'content_libraries.publish_library_content',
+  REUSE_LIBRARY_CONTENT: 'content_libraries.reuse_library_content',
+
+  CREATE_LIBRARY_COLLECTION: 'content_libraries.create_library_collection',
+  EDIT_LIBRARY_COLLECTION: 'content_libraries.edit_library_collection',
+  DELETE_LIBRARY_COLLECTION: 'content_libraries.delete_library_collection',
+
+  MANAGE_LIBRARY_TEAM: 'content_libraries.manage_library_team',
+  VIEW_LIBRARY_TEAM: 'content_libraries.view_library_team',
+};
+
+export const CONTENT_COURSE_PERMISSIONS = {
+  VIEW_COURSE: 'courses.view_course',
+  CREATE_COURSE: 'courses.create_course',
+  EDIT_COURSE_CONTENT: 'courses.edit_course_content',
+  PUBLISH_COURSE_CONTENT: 'courses.publish_course_content',
+
+  REVIEW_COURSE_LIBRARY_UPDATES: 'courses.manage_library_updates',
+
+  VIEW_COURSE_UPDATES: 'courses.view_course_updates',
+  MANAGE_COURSE_UPDATES: 'courses.manage_course_updates',
+
+  VIEW_COURSE_PAGES_RESOURCES: 'courses.view_pages_and_resources',
+  MANAGE_COURSE_PAGES_RESOURCES: 'courses.manage_pages_and_resources',
+
+  VIEW_COURSE_FILES: 'courses.view_files',
+  CREATE_COURSE_FILES: 'courses.create_files',
+  EDIT_COURSE_FILES: 'courses.edit_files',
+  DELETE_COURSE_FILES: 'courses.delete_files',
+
+  VIEW_COURSE_SCHEDULE: 'courses.view_schedule',
+  EDIT_COURSE_SCHEDULE: 'courses.edit_schedule',
+  VIEW_COURSE_DETAILS: 'courses.view_details',
+  EDIT_COURSE_DETAILS: 'courses.edit_details',
+
+  VIEW_COURSE_GRADING_SETTINGS: 'courses.view_grading_settings',
+  EDIT_COURSE_GRADING_SETTINGS: 'courses.edit_grading_settings',
+
+  VIEW_COURSE_TEAM: 'courses.view_course_team',
+  MANAGE_COURSE_TEAM: 'courses.manage_course_team',
+  MANAGE_COURSE_GROUP_CONFIGURATION: 'courses.manage_group_configurations',
+
+  MANAGE_COURSE_TAGS: 'courses.manage_tags',
+  MANAGE_COURSE_TAXONOMIES: 'courses.manage_taxonomies',
+
+  MANAGE_COURSE_ADVANCED_SETTINGS: 'courses.manage_advanced_settings',
+  MANAGE_COURSE_CERTIFICATES: 'courses.manage_certificates',
+
+  IMPORT_COURSE: 'courses.import_course',
+  EXPORT_COURSE: 'courses.export_course',
+  EXPORT_COURSE_TAGS: 'courses.export_tags',
+
+  VIEW_COURSE_CHECKLISTS: 'courses.view_checklists',
+  VIEW_COURSE_GLOBAL_STAFF_SUPER_ADMINS: 'courses.view_global_staff_and_superadmins',
+};
+
+// Note: this information will eventually come from the backend API
+// but for the MVP we decided to manage it in the frontend
+export const libraryRolesMetadata: RoleMetadata[] = [
+  { role: 'library_admin', name: 'Library Admin', description: 'The Library Admin has full control over the library, including managing users, modifying content, and handling publishing workflows. They ensure content is properly maintained and accessible as needed.' },
+  { role: 'library_author', name: 'Library Author', description: 'The Library Author is responsible for creating, editing, and publishing content within a library. They can manage tags and collections but cannot delete libraries or manage users.' },
+  { role: 'library_contributor', name: 'Library Contributor', description: 'The Library Contributor can create and edit content within a library but cannot publish it. They support the authoring process while leaving final publishing to Authors or Admins.' },
+  { role: 'library_user', name: 'Library User', description: 'The Library User can view and reuse content but cannot edit or delete any resource.' },
+];
+
+export const libraryResourceTypes: ResourceMetadata[] = [
+  { key: 'library', label: 'Library', description: 'Permissions related to the library as a whole.' },
+  { key: 'library_content', label: 'Content', description: 'Permissions to create, edit, delete, and publish individual content items within the library.' },
+  { key: 'library_collection', label: 'Collection', description: 'Permissions to create, edit, and delete content collections within the library.' },
+  { key: 'library_team', label: 'Team', description: 'Permissions to manage user access and roles within the library.' },
+];
+
+export const libraryPermissions: PermissionMetadata[] = [
+  { key: CONTENT_LIBRARY_PERMISSIONS.DELETE_LIBRARY, resource: 'library', description: 'Allows the user to delete the library and all its contents.' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.MANAGE_LIBRARY_TAGS, resource: 'library', description: 'Add or remove tags from content.' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.VIEW_LIBRARY, resource: 'library', description: 'View content, search, filter, and sort within the library.' },
+
+  { key: CONTENT_LIBRARY_PERMISSIONS.EDIT_LIBRARY_CONTENT, resource: 'library_content', description: 'Edit content in draft mode' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.PUBLISH_LIBRARY_CONTENT, resource: 'library_content', description: 'Publish content, making it available for reuse' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.REUSE_LIBRARY_CONTENT, resource: 'library_content', description: 'Reuse published content within a course.' },
+
+  { key: CONTENT_LIBRARY_PERMISSIONS.CREATE_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Create new collections within a library.' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.EDIT_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Add or remove content from existing collections.' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.DELETE_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Delete entire collections from the library.' },
+
+  { key: CONTENT_LIBRARY_PERMISSIONS.MANAGE_LIBRARY_TEAM, resource: 'library_team', description: 'View the list of users who have access to the library.' },
+  { key: CONTENT_LIBRARY_PERMISSIONS.VIEW_LIBRARY_TEAM, resource: 'library_team', description: 'Add, remove, and assign roles to users within the library.' },
+];
+
+export const DEFAULT_TOAST_DELAY = 5000;
+export const RETRY_TOAST_DELAY = 120_000; // 2 minutes
+export const SKELETON_ROWS = Array.from({ length: 10 }).map(() => ({
+  username: 'skeleton',
+  name: '',
+  email: '',
+  roles: [],
+}));
+
 export const ROUTES = {
   LIBRARIES_TEAM_PATH: '/libraries/:libraryId',
   LIBRARIES_USER_PATH: '/libraries/:libraryId/:username',
+  AUDIT_USER_PATH: '/user/:username',
 };
 
 export enum RoleOperationErrorStatus {
@@ -10,3 +117,24 @@ export enum RoleOperationErrorStatus {
   ROLE_ASSIGNMENT_ERROR = 'role_assignment_error',
   ROLE_REMOVAL_ERROR = 'role_removal_error',
 }
+
+export const TABLE_DEFAULT_PAGE_SIZE = 10;
+
+export const AUTHZ_HOME_PATH = '/authz';
+
+export const MAP_ROLE_KEY_TO_LABEL: Record<string, string> = {
+  library_admin: 'Library Admin',
+  library_author: 'Library Author',
+  library_contributor: 'Library Contributor',
+  library_user: 'Library User',
+  course_admin: 'Course Admin',
+  course_staff: 'Course Staff',
+  course_editor: 'Course Editor',
+  course_auditor: 'Course Auditor',
+  'django.superuser': 'Super Admin',
+  'django.globalstaff': 'Global Staff',
+};
+
+export const DJANGO_MANAGED_ROLES = ['django.superuser', 'django.globalstaff'];
+
+export const ADMIN_ROLES = ['course_admin', 'library_admin'];
diff --git a/src/authz-module/data/api.ts b/src/authz-module/data/api.ts
index bf5ff1ae..b4467d6a 100644
--- a/src/authz-module/data/api.ts
+++ b/src/authz-module/data/api.ts
@@ -1,5 +1,5 @@
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
-import { LibraryMetadata, TeamMember } from '@src/types';
+import { LibraryMetadata, TeamMember, UserRole } from '@src/types';
 import { camelCaseObject } from '@edx/frontend-platform';
 import { getApiUrl, getStudioApiUrl } from '@src/data/utils';
 
@@ -17,10 +17,18 @@ export interface GetTeamMembersResponse {
   count: number;
 }
 
+export interface GetUserAssignmentsResponse {
+  results: UserRole[];
+  count: number;
+  next: string | null;
+  previous: string | null;
+}
+
 export type RevokeUserRolesRequest = {
   users: string;
   role: string;
   scope: string;
+  querySettings?: QuerySettings;
 };
 
 export interface DeleteRevokeUserRolesResponse {
@@ -108,3 +116,24 @@ export const revokeUserRoles = async (
   const res = await getAuthenticatedHttpClient().delete(url.toString());
   return camelCaseObject(res.data);
 };
+
+export const getUserAssignedRoles = async (username: string, querySettings: QuerySettings)
+: Promise<GetUserAssignmentsResponse> => {
+  const url = new URL(getApiUrl(`/api/authz/v1/users/${username}/assignments/`));
+
+  if (querySettings.roles) {
+    url.searchParams.set('roles', querySettings.roles);
+  }
+  if (querySettings.search) {
+    url.searchParams.set('search', querySettings.search);
+  }
+  if (querySettings.sortBy && querySettings.order) {
+    url.searchParams.set('sort_by', querySettings.sortBy);
+    url.searchParams.set('order', querySettings.order);
+  }
+  url.searchParams.set('page_size', querySettings.pageSize.toString());
+  url.searchParams.set('page', (querySettings.pageIndex + 1).toString());
+
+  const { data } = await getAuthenticatedHttpClient().get(url);
+  return camelCaseObject(data);
+};
diff --git a/src/authz-module/libraries-manager/ToastManagerContext.test.tsx b/src/authz-module/data/context/ToastManagerContext.test.tsx
similarity index 100%
rename from src/authz-module/libraries-manager/ToastManagerContext.test.tsx
rename to src/authz-module/data/context/ToastManagerContext.test.tsx
diff --git a/src/authz-module/libraries-manager/ToastManagerContext.tsx b/src/authz-module/data/context/ToastManagerContext.tsx
similarity index 85%
rename from src/authz-module/libraries-manager/ToastManagerContext.tsx
rename to src/authz-module/data/context/ToastManagerContext.tsx
index 55be67a0..04b76c7c 100644
--- a/src/authz-module/libraries-manager/ToastManagerContext.tsx
+++ b/src/authz-module/data/context/ToastManagerContext.tsx
@@ -4,20 +4,20 @@ import {
 import { logError } from '@edx/frontend-platform/logging';
 import { useIntl } from '@edx/frontend-platform/i18n';
 import { Toast } from '@openedx/paragon';
-import messages from './messages';
-import { DEFAULT_TOAST_DELAY, RETRY_TOAST_DELAY } from './constants';
+import messages from '@src/authz-module/messages';
+import { DEFAULT_TOAST_DELAY, RETRY_TOAST_DELAY } from '../../constants';
 
 type ToastType = 'success' | 'error' | 'error-retry';
 
 export const ERROR_TOAST_MAP: Record<number | string, { type: ToastType; messageId: string }> = {
   // Transient (retryable) server errors
-  500: { type: 'error-retry', messageId: 'library.authz.team.toast.500.error.message' },
-  502: { type: 'error-retry', messageId: 'library.authz.team.toast.502.error.message' },
-  503: { type: 'error-retry', messageId: 'library.authz.team.toast.503.error.message' },
-  408: { type: 'error-retry', messageId: 'library.authz.team.toast.408.error.message' },
+  500: { type: 'error-retry', messageId: 'authz.team.toast.500.error.message' },
+  502: { type: 'error-retry', messageId: 'authz.team.toast.502.error.message' },
+  503: { type: 'error-retry', messageId: 'authz.team.toast.503.error.message' },
+  408: { type: 'error-retry', messageId: 'authz.team.toast.408.error.message' },
 
   // Generic fallback error
-  DEFAULT: { type: 'error-retry', messageId: 'library.authz.team.toast.default.error.message' },
+  DEFAULT: { type: 'error-retry', messageId: 'authz.team.toast.default.error.message' },
 };
 
 export interface AppToast {
@@ -108,7 +108,7 @@ export const ToastManagerProvider = ({ children }: ToastManagerProviderProps) =>
                 discardToast(toast.id);
                 toast.onRetry?.();
               },
-              label: intl.formatMessage(messages['library.authz.team.toast.retry.label']),
+              label: intl.formatMessage(messages['authz.team.toast.retry.label']),
             } : undefined}
           >
             {toast.message}
diff --git a/src/authz-module/data/hooks.test.tsx b/src/authz-module/data/hooks.test.tsx
index d55c7e0a..1cc82724 100644
--- a/src/authz-module/data/hooks.test.tsx
+++ b/src/authz-module/data/hooks.test.tsx
@@ -3,7 +3,7 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import {
-  useLibrary, usePermissionsByRole, useTeamMembers, useAssignTeamMembersRole, useRevokeUserRoles,
+  useLibrary, usePermissionsByRole, useTeamMembers, useAssignTeamMembersRole, useRevokeUserRoles, useUserAssignedRoles,
 } from './hooks';
 
 jest.mock('@edx/frontend-platform/auth', () => ({
@@ -35,7 +35,16 @@ const mockLibrary = {
   slug: 'test-library',
 };
 
-const mockQuerySettings = {
+type QuerySettings = {
+  roles: string | null;
+  search: string | null;
+  order: string | null;
+  sortBy: string | null;
+  pageSize: number;
+  pageIndex: number;
+};
+
+const mockQuerySettings: QuerySettings = {
   roles: null,
   search: null,
   order: null,
@@ -44,6 +53,53 @@ const mockQuerySettings = {
   pageIndex: 0,
 };
 
+const mockUserAssignments = {
+  count: 3,
+  results: [
+    {
+      id: '1',
+      role: 'library_admin',
+      scope: 'lib:test-library-1',
+      permissionCount: 15,
+    },
+    {
+      id: '2',
+      role: 'course_staff',
+      scope: 'course:test-course-1',
+      permissionCount: 8,
+    },
+    {
+      id: '3',
+      role: 'django.superuser',
+      scope: 'global',
+      permissionCount: 50,
+    },
+  ],
+  next: 'http://api.example.com/userAssignments?page=2',
+  previous: null,
+};
+
+const mockEmptyUserAssignments = {
+  count: 0,
+  results: [],
+  next: null,
+  previous: null,
+};
+
+const mockFilteredUserAssignments = {
+  count: 1,
+  results: [
+    {
+      id: '1',
+      role: 'library_admin',
+      scope: 'lib:test-library-1',
+      permissionCount: 15,
+    },
+  ],
+  next: null,
+  previous: null,
+};
+
 const createWrapper = () => {
   const queryClient = new QueryClient({
     defaultOptions: {
@@ -340,3 +396,131 @@ describe('useRevokeUserRoles', () => {
     expect(calledUrl.searchParams.get('scope')).toBe(revokeRoleData.scope);
   });
 });
+
+describe('useUserAssignedRoles', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns user role assignments when API call succeeds', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: mockUserAssignments }),
+    });
+
+    const { result } = renderHook(() => useUserAssignedRoles('john.doe', mockQuerySettings), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(getAuthenticatedHttpClient).toHaveBeenCalled();
+    expect(result.current.data).toEqual(mockUserAssignments);
+    expect(result.current.data?.results).toHaveLength(3);
+    expect(result.current.data?.count).toBe(3);
+  });
+
+  it('returns empty results when user has no role assignments', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: mockEmptyUserAssignments }),
+    });
+
+    const { result } = renderHook(() => useUserAssignedRoles('newuser', mockQuerySettings), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.results).toHaveLength(0);
+    expect(result.current.data?.count).toBe(0);
+    expect(result.current.data?.next).toBeNull();
+  });
+
+  it('applies query settings for filtering and pagination', async () => {
+    const filteredQuerySettings = {
+      ...mockQuerySettings,
+      roles: 'library_admin',
+      search: 'library',
+      pageSize: 5,
+      pageIndex: 1,
+    };
+
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: mockFilteredUserAssignments }),
+    });
+
+    const { result } = renderHook(() => useUserAssignedRoles('john.doe', filteredQuerySettings), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.results).toHaveLength(1);
+    expect(result.current.data?.results[0].role).toBe('library_admin');
+  });
+
+  it('handles API error when fetching user assignments fails', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockRejectedValue(new Error('User not found')),
+    });
+
+    const { result } = renderHook(() => useUserAssignedRoles('nonexistent.user', mockQuerySettings), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+
+    expect(result.current.error?.message).toBe('User not found');
+    expect(result.current.data).toBeUndefined();
+  });
+
+  it('does not refetch on window focus', async () => {
+    const mockGet = jest.fn().mockResolvedValue({ data: mockUserAssignments });
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: mockGet,
+    });
+
+    const { result } = renderHook(() => useUserAssignedRoles('john.doe', mockQuerySettings), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    act(() => {
+      window.dispatchEvent(new Event('focus'));
+    });
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates when query settings change', async () => {
+    const mockGet = jest.fn()
+      .mockResolvedValueOnce({ data: mockUserAssignments })
+      .mockResolvedValueOnce({ data: mockFilteredUserAssignments });
+
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: mockGet,
+    });
+
+    const { result, rerender } = renderHook(
+      ({ querySettings }) => useUserAssignedRoles('john.doe', querySettings),
+      {
+        wrapper: createWrapper(),
+        initialProps: { querySettings: mockQuerySettings },
+      },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.count).toBe(3);
+
+    rerender({
+      querySettings: {
+        ...mockQuerySettings,
+        roles: 'library_admin',
+        pageSize: 1,
+      },
+    });
+
+    await waitFor(() => expect(result.current.data?.count).toBe(1));
+    expect(mockGet).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/src/authz-module/data/hooks.ts b/src/authz-module/data/hooks.ts
index bc5090e0..8a71c26a 100644
--- a/src/authz-module/data/hooks.ts
+++ b/src/authz-module/data/hooks.ts
@@ -5,7 +5,8 @@ import { appId } from '@src/constants';
 import { LibraryMetadata } from '@src/types';
 import {
   assignTeamMembersRole, AssignTeamMembersRoleRequest, getLibrary, getPermissionsByRole, getTeamMembers,
-  GetTeamMembersResponse, PermissionsByRole, QuerySettings, revokeUserRoles, RevokeUserRolesRequest,
+  GetTeamMembersResponse, getUserAssignedRoles, GetUserAssignmentsResponse, PermissionsByRole, QuerySettings,
+  revokeUserRoles, RevokeUserRolesRequest,
 } from './api';
 
 const authzQueryKeys = {
@@ -15,6 +16,7 @@ const authzQueryKeys = {
     ...authzQueryKeys.teamMembersAll(scope), querySettings] as const,
   permissionsByRole: (scope: string) => [...authzQueryKeys.all, 'permissionsByRole', scope] as const,
   library: (libraryId: string) => [...authzQueryKeys.all, 'library', libraryId] as const,
+  userRoles: (username: string, querySettings?: QuerySettings) => [...authzQueryKeys.all, 'userRoles', username, querySettings] as const,
 };
 
 /**
@@ -104,9 +106,22 @@ export const useRevokeUserRoles = () => {
     mutationFn: async ({ data }: {
       data: RevokeUserRolesRequest
     }) => revokeUserRoles(data),
-    onSettled: (_data, _error, { data: { scope } }) => {
+    onSettled: (_data, _error, { data: { scope, users, querySettings } }) => {
       queryClient.invalidateQueries({ queryKey: authzQueryKeys.teamMembersAll(scope) });
       queryClient.invalidateQueries({ queryKey: authzQueryKeys.permissionsByRole(scope) });
+      queryClient.invalidateQueries({
+        queryKey: authzQueryKeys.userRoles(users, querySettings),
+      });
     },
   });
 };
+
+export const useUserAssignedRoles = (username: string, querySettings: QuerySettings) => {
+  const result = useQuery<GetUserAssignmentsResponse, Error>({
+    queryKey: authzQueryKeys.userRoles(username, querySettings),
+    queryFn: () => getUserAssignedRoles(username, querySettings),
+    staleTime: 1000 * 60 * 30, // refetch after 30 minutes
+    refetchOnWindowFocus: false,
+  });
+  return result;
+};
diff --git a/src/authz-module/libraries-manager/components/TeamTable/hooks/useQuerySettings.test.ts b/src/authz-module/hooks/useQuerySettings.test.ts
similarity index 100%
rename from src/authz-module/libraries-manager/components/TeamTable/hooks/useQuerySettings.test.ts
rename to src/authz-module/hooks/useQuerySettings.test.ts
diff --git a/src/authz-module/libraries-manager/components/TeamTable/hooks/useQuerySettings.ts b/src/authz-module/hooks/useQuerySettings.ts
similarity index 83%
rename from src/authz-module/libraries-manager/components/TeamTable/hooks/useQuerySettings.ts
rename to src/authz-module/hooks/useQuerySettings.ts
index 3c7d879f..32c55c1b 100644
--- a/src/authz-module/libraries-manager/components/TeamTable/hooks/useQuerySettings.ts
+++ b/src/authz-module/hooks/useQuerySettings.ts
@@ -41,8 +41,8 @@ export const useQuerySettings = (
   const handleTableFetch = useCallback((tableFilters: DataTableFilters) => {
     setQuerySettings((prevSettings) => {
       // Extract filters
-      const rolesFilter = tableFilters.filters.find((filter) => filter.id === 'roles')?.value?.join(',') ?? '';
-      const searchFilter = tableFilters.filters.find((filter) => filter.id === 'username')?.value ?? '';
+      const rolesFilter = tableFilters.filters?.find((filter) => filter.id === 'roles')?.value?.join(',') ?? '';
+      const searchFilter = tableFilters.filters?.find((filter) => filter.id === 'username')?.value ?? '';
 
       // Extract pagination
       const { pageSize = 10, pageIndex = 0 } = tableFilters;
@@ -50,9 +50,9 @@ export const useQuerySettings = (
       // Extract and convert sorting
       let sortByOption = '';
       let sortByOrder = '';
-      if (tableFilters.sortBy.length) {
-        sortByOption = tableFilters.sortBy[0].id.replace(/([A-Z])/g, '_$1').toLowerCase();
-        sortByOrder = tableFilters.sortBy[0].desc ? SortOrderKeys.DESC : SortOrderKeys.ASC;
+      if (tableFilters.sortBy?.length) {
+        sortByOption = tableFilters.sortBy[0]?.id.replace(/([A-Z])/g, '_$1').toLowerCase();
+        sortByOrder = tableFilters.sortBy[0]?.desc ? SortOrderKeys.DESC : SortOrderKeys.ASC;
       }
 
       const newQuerySettings: QuerySettings = {
diff --git a/src/authz-module/index.scss b/src/authz-module/index.scss
index 4c6ef34f..4372c76c 100644
--- a/src/authz-module/index.scss
+++ b/src/authz-module/index.scss
@@ -1,19 +1,17 @@
 @use "@openedx/paragon/styles/css/core/custom-media-breakpoints" as paragonCustomMediaBreakpoints;
 
-.authz-libraries {
+.authz-module {
   --height-action-divider: 30px;
 
   hr {
-    border-top: var(--pgn-size-border-width) solid var(--pgn-color-border);
-    width: 100%;
+    border-right: var(--pgn-size-border-width) solid var(--pgn-color-border);
+    height: var(--height-action-divider);
+    width: 0;
   }
 
-  @media (--pgn-size-breakpoint-min-width-lg) {
-    hr {
-      border-right: var(--pgn-size-border-width) solid var(--pgn-color-border);
-      height: var(--height-action-divider);
-      width: 0;
-    }
+  .pgn__data-table tr:has(td[data-role="Super Admin"]),
+  .pgn__data-table tr:has(td[data-role="Global Staff"]) {
+    background-color: var(--pgn-color-primary-200);
   }
 
   .tab-content {
@@ -52,6 +50,17 @@
       line-height: 24px;
     }
   }
+  
+  @media(--pgn-size-breakpoint-max-width-sm){
+    .flex-column-sm {
+      flex-direction: column;
+    }
+    hr {
+      border-top: var(--pgn-size-border-width) solid var(--pgn-color-border);
+      border-right: none;
+      width: 100%;
+    }
+  }
 }
 
 .toast-container {
diff --git a/src/authz-module/index.tsx b/src/authz-module/index.tsx
index a5b6cbcc..1422b705 100644
--- a/src/authz-module/index.tsx
+++ b/src/authz-module/index.tsx
@@ -5,9 +5,10 @@ import { QueryErrorResetBoundary } from '@tanstack/react-query';
 import LoadingPage from '@src/components/LoadingPage';
 import LibrariesErrorFallback from '@src/authz-module/libraries-manager/ErrorPage';
 import { CustomErrors } from '@src/constants';
-import { ToastManagerProvider } from './libraries-manager/ToastManagerContext';
+import { ToastManagerProvider } from './data/context/ToastManagerContext';
 import { LibrariesUserManager, LibrariesLayout, LibrariesTeamManager } from './libraries-manager';
 import AuthzHome from './authz-home';
+import AuditUserPage from './audit-user';
 import { ROUTES } from './constants';
 
 import './index.scss';
@@ -30,6 +31,10 @@ const AuthZModule = () => (
               </Route>
               <Route index element={<AuthzHome />} />
               <Route path="*" element={<NotFoundError />} />
+              <Route
+                path={ROUTES.AUDIT_USER_PATH}
+                element={<AuditUserPage />}
+              />
             </Routes>
           </Suspense>
         </ToastManagerProvider>
diff --git a/src/authz-module/libraries-manager/LibrariesTeamManager.test.tsx b/src/authz-module/libraries-manager/LibrariesTeamManager.test.tsx
index 0e64ca76..205ed9bd 100644
--- a/src/authz-module/libraries-manager/LibrariesTeamManager.test.tsx
+++ b/src/authz-module/libraries-manager/LibrariesTeamManager.test.tsx
@@ -2,11 +2,11 @@ import { screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { renderWrapper } from '@src/setupTest';
 import { initializeMockApp } from '@edx/frontend-platform/testing';
-import { useLibrary, useUpdateLibrary } from '@src/authz-module/data/hooks';
+import { useLibrary } from '@src/authz-module/data/hooks';
 import { useLibraryAuthZ } from './context';
 import LibrariesTeamManager from './LibrariesTeamManager';
-import { ToastManagerProvider } from './ToastManagerContext';
-import { CONTENT_LIBRARY_PERMISSIONS } from './constants';
+import { ToastManagerProvider } from '../data/context/ToastManagerContext';
+import { CONTENT_LIBRARY_PERMISSIONS } from '../constants';
 
 jest.mock('./context', () => {
   const actual = jest.requireActual('./context');
@@ -21,7 +21,6 @@ const mockedUseLibraryAuthZ = useLibraryAuthZ as jest.Mock;
 
 jest.mock('@src/authz-module/data/hooks', () => ({
   useLibrary: jest.fn(),
-  useUpdateLibrary: jest.fn(),
 }));
 
 jest.mock('./components/TeamTable', () => ({
@@ -57,7 +56,6 @@ describe('LibrariesTeamManager', () => {
     org: 'Test Org',
     allowPublicRead: false,
   };
-  const mutate = jest.fn();
   const libraryAuthZContext = {
     libraryId: libraryData.id,
     libraryName: libraryData.title,
@@ -91,10 +89,6 @@ describe('LibrariesTeamManager', () => {
     (useLibrary as jest.Mock).mockReturnValue({
       data: libraryData,
     });
-    (useUpdateLibrary as jest.Mock).mockReturnValue({
-      mutate,
-      isPending: false,
-    });
   });
 
   it('renders tabs and layout content correctly', () => {
diff --git a/src/authz-module/libraries-manager/LibrariesTeamManager.tsx b/src/authz-module/libraries-manager/LibrariesTeamManager.tsx
index fa4b2c60..f8a7ed46 100644
--- a/src/authz-module/libraries-manager/LibrariesTeamManager.tsx
+++ b/src/authz-module/libraries-manager/LibrariesTeamManager.tsx
@@ -40,7 +40,7 @@ const LibrariesTeamManager = () => {
   }, [roles, permissions, resources, intl]);
 
   return (
-    <div className="authz-libraries">
+    <div className="authz-module">
       <AuthZLayout
         context={{ id: libraryId, title: library.title, org: library.org }}
         // Temporarily setting '/authz/libraries/:libraryId' as the URL for Manage Access breadcrumb for now as
diff --git a/src/authz-module/libraries-manager/LibrariesUserManager.test.tsx b/src/authz-module/libraries-manager/LibrariesUserManager.test.tsx
index 77ea2ca9..2a125883 100644
--- a/src/authz-module/libraries-manager/LibrariesUserManager.test.tsx
+++ b/src/authz-module/libraries-manager/LibrariesUserManager.test.tsx
@@ -5,7 +5,7 @@ import { renderWrapper } from '@src/setupTest';
 import LibrariesUserManager from './LibrariesUserManager';
 import { useLibraryAuthZ } from './context';
 import { useLibrary, useTeamMembers, useRevokeUserRoles } from '../data/hooks';
-import { ToastManagerProvider } from './ToastManagerContext';
+import { ToastManagerProvider } from '../data/context/ToastManagerContext';
 
 jest.mock('@edx/frontend-platform/logging', () => ({
   logError: jest.fn(),
diff --git a/src/authz-module/libraries-manager/LibrariesUserManager.tsx b/src/authz-module/libraries-manager/LibrariesUserManager.tsx
index cc2f0822..3d4c1cd0 100644
--- a/src/authz-module/libraries-manager/LibrariesUserManager.tsx
+++ b/src/authz-module/libraries-manager/LibrariesUserManager.tsx
@@ -4,7 +4,7 @@ import { useIntl } from '@edx/frontend-platform/i18n';
 import { Container, Skeleton } from '@openedx/paragon';
 import { ROUTES } from '@src/authz-module/constants';
 import { Role } from 'types';
-import { useToastManager } from '@src/authz-module/libraries-manager/ToastManagerContext';
+import { useToastManager } from '@src/authz-module/data/context/ToastManagerContext';
 import AuthZLayout from '../components/AuthZLayout';
 import { useLibraryAuthZ } from './context';
 import RoleCard from '../components/RoleCard';
@@ -131,7 +131,7 @@ const LibrariesUserManager = () => {
   };
 
   return (
-    <div className="authz-libraries">
+    <div className="authz-module">
       <ConfirmDeletionModal
         isOpen={showConfirmDeletionModal}
         close={handleCloseConfirmDeletionModal}
diff --git a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.test.tsx b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.test.tsx
index 727d6a1f..70456581 100644
--- a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.test.tsx
+++ b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.test.tsx
@@ -3,7 +3,7 @@ import { screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { renderWrapper } from '@src/setupTest';
 import { useAssignTeamMembersRole } from '@src/authz-module/data/hooks';
-import { ToastManagerProvider } from '@src/authz-module/libraries-manager/ToastManagerContext';
+import { ToastManagerProvider } from '@src/authz-module/data/context/ToastManagerContext';
 import AddNewTeamMemberTrigger from './AddNewTeamMemberTrigger';
 
 jest.mock('@edx/frontend-platform/logging');
diff --git a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.tsx b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.tsx
index 0ed2346a..99d23bbf 100644
--- a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.tsx
+++ b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/AddNewTeamMemberTrigger.tsx
@@ -3,11 +3,11 @@ import { useIntl } from '@edx/frontend-platform/i18n';
 import { Button, useToggle } from '@openedx/paragon';
 import { Plus } from '@openedx/paragon/icons';
 
-import { PutAssignTeamMembersRoleResponse } from 'authz-module/data/api';
+import { PutAssignTeamMembersRoleResponse } from '@src/authz-module/data/api';
 import { useAssignTeamMembersRole } from '@src/authz-module/data/hooks';
-import { RoleOperationErrorStatus } from '@src/authz-module/constants';
-import { AppToast, useToastManager } from '@src/authz-module/libraries-manager/ToastManagerContext';
-import { DEFAULT_TOAST_DELAY } from '@src/authz-module/libraries-manager/constants';
+import { RoleOperationErrorStatus, DEFAULT_TOAST_DELAY } from '@src/authz-module/constants';
+import { AppToast, useToastManager } from '@src/authz-module/data/context/ToastManagerContext';
+import baseMessages from '@src/authz-module/messages';
 import AddNewTeamMemberModal from './AddNewTeamMemberModal';
 import messages from './messages';
 
@@ -201,7 +201,7 @@ const AddNewTeamMemberTrigger = ({ libraryId }: AddNewTeamMemberTriggerProps) =>
         onClick={open}
         disabled={isPending}
       >
-        {intl.formatMessage(messages['authz.manage.assign.role.title'])}
+        {intl.formatMessage(baseMessages['authz.management.assign.role.title'])}
       </Button>
 
       {isOpen && (
diff --git a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/messages.ts b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/messages.ts
index fb6c516f..05e28d5e 100644
--- a/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/messages.ts
+++ b/src/authz-module/libraries-manager/components/AddNewTeamMemberModal/messages.ts
@@ -1,11 +1,6 @@
 import { defineMessages } from '@edx/frontend-platform/i18n';
 
 const messages = defineMessages({
-  'authz.manage.assign.role.title': {
-    id: 'authz.manage.assign.role.title',
-    defaultMessage: 'Assign Role',
-    description: 'Text for the assign role button',
-  },
   'libraries.authz.manage.add.member.title': {
     id: 'libraries.authz.manage.add.member.title',
     defaultMessage: 'Add New Team Member',
diff --git a/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.test.tsx b/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.test.tsx
index a8d10830..c63f4832 100644
--- a/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.test.tsx
+++ b/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.test.tsx
@@ -3,7 +3,7 @@ import userEvent from '@testing-library/user-event';
 import { renderWrapper } from '@src/setupTest';
 import { useLibraryAuthZ } from '@src/authz-module/libraries-manager/context';
 import { useAssignTeamMembersRole } from '@src/authz-module/data/hooks';
-import { ToastManagerProvider } from '@src/authz-module/libraries-manager/ToastManagerContext';
+import { ToastManagerProvider } from '@src/authz-module/data/context/ToastManagerContext';
 import AssignNewRoleTrigger from './AssignNewRoleTrigger';
 
 jest.mock('@edx/frontend-platform/logging');
diff --git a/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.tsx b/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.tsx
index dc04c642..88023730 100644
--- a/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.tsx
+++ b/src/authz-module/libraries-manager/components/AssignNewRoleModal/AssignNewRoleTrigger.tsx
@@ -5,7 +5,7 @@ import { Plus } from '@openedx/paragon/icons';
 
 import { useLibraryAuthZ } from '@src/authz-module/libraries-manager/context';
 import { useAssignTeamMembersRole } from '@src/authz-module/data/hooks';
-import { useToastManager } from '@src/authz-module/libraries-manager/ToastManagerContext';
+import { useToastManager } from '@src/authz-module/data/context/ToastManagerContext';
 import AssignNewRoleModal from './AssignNewRoleModal';
 
 import messages from '../messages';
diff --git a/src/authz-module/libraries-manager/components/TeamTable/components/Cells.test.tsx b/src/authz-module/libraries-manager/components/TeamTable/components/Cells.test.tsx
index fe7c9404..ce627b32 100644
--- a/src/authz-module/libraries-manager/components/TeamTable/components/Cells.test.tsx
+++ b/src/authz-module/libraries-manager/components/TeamTable/components/Cells.test.tsx
@@ -23,7 +23,7 @@ jest.mock('@src/authz-module/data/hooks', () => ({
   useTeamMembers: jest.fn(),
 }));
 
-jest.mock('../hooks/useQuerySettings', () => ({
+jest.mock('@src/authz-module/hooks/useQuerySettings', () => ({
   useQuerySettings: jest.fn(() => ({
     querySettings: { page: 1, limit: 10 },
   })),
diff --git a/src/authz-module/libraries-manager/components/TeamTable/components/Cells.tsx b/src/authz-module/libraries-manager/components/TeamTable/components/Cells.tsx
index 9f160994..9f0faa43 100644
--- a/src/authz-module/libraries-manager/components/TeamTable/components/Cells.tsx
+++ b/src/authz-module/libraries-manager/components/TeamTable/components/Cells.tsx
@@ -5,8 +5,8 @@ import { TableCellValue, TeamMember } from '@src/types';
 import { useLibraryAuthZ } from '@src/authz-module/libraries-manager/context';
 import { useNavigate } from 'react-router-dom';
 import { useTeamMembers } from '@src/authz-module/data/hooks';
-import { SKELETON_ROWS } from '@src/authz-module/libraries-manager/constants';
-import { useQuerySettings } from '../hooks/useQuerySettings';
+import { SKELETON_ROWS } from '@src/authz-module/constants';
+import { useQuerySettings } from '@src/authz-module/hooks/useQuerySettings';
 import messages from '../messages';
 
 type CellProps = TableCellValue<TeamMember>;
diff --git a/src/authz-module/libraries-manager/components/TeamTable/index.test.tsx b/src/authz-module/libraries-manager/components/TeamTable/index.test.tsx
index 719edb87..3d809e58 100644
--- a/src/authz-module/libraries-manager/components/TeamTable/index.test.tsx
+++ b/src/authz-module/libraries-manager/components/TeamTable/index.test.tsx
@@ -3,8 +3,8 @@ import userEvent from '@testing-library/user-event';
 import { renderWrapper } from '@src/setupTest';
 import { useTeamMembers } from '@src/authz-module/data/hooks';
 import { useLibraryAuthZ } from '@src/authz-module/libraries-manager/context';
-import { ToastManagerProvider } from '@src/authz-module/libraries-manager/ToastManagerContext';
-import { CONTENT_LIBRARY_PERMISSIONS } from '@src/authz-module/libraries-manager/constants';
+import { ToastManagerProvider } from '@src/authz-module/data/context/ToastManagerContext';
+import { CONTENT_LIBRARY_PERMISSIONS } from '@src/authz-module/constants';
 import TeamTable from './index';
 
 const mockNavigate = jest.fn();
diff --git a/src/authz-module/libraries-manager/components/TeamTable/index.tsx b/src/authz-module/libraries-manager/components/TeamTable/index.tsx
index 3763bd8d..704fb1d6 100644
--- a/src/authz-module/libraries-manager/components/TeamTable/index.tsx
+++ b/src/authz-module/libraries-manager/components/TeamTable/index.tsx
@@ -10,9 +10,9 @@ import {
 
 import { useTeamMembers } from '@src/authz-module/data/hooks';
 import { useLibraryAuthZ } from '@src/authz-module/libraries-manager/context';
-import { useToastManager } from '@src/authz-module/libraries-manager/ToastManagerContext';
-import { SKELETON_ROWS } from '@src/authz-module/libraries-manager/constants';
-import { useQuerySettings } from './hooks/useQuerySettings';
+import { useToastManager } from '@src/authz-module/data/context/ToastManagerContext';
+import { SKELETON_ROWS } from '@src/authz-module/constants';
+import { useQuerySettings } from '@src/authz-module/hooks/useQuerySettings';
 import TableControlBar from './components/TableControlBar';
 import messages from './messages';
 import {
diff --git a/src/authz-module/libraries-manager/constants.ts b/src/authz-module/libraries-manager/constants.ts
deleted file mode 100644
index d1368961..00000000
--- a/src/authz-module/libraries-manager/constants.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { PermissionMetadata, ResourceMetadata, RoleMetadata } from 'types';
-
-export const CONTENT_LIBRARY_PERMISSIONS = {
-  DELETE_LIBRARY: 'content_libraries.delete_library',
-  MANAGE_LIBRARY_TAGS: 'content_libraries.manage_library_tags',
-  VIEW_LIBRARY: 'content_libraries.view_library',
-
-  EDIT_LIBRARY_CONTENT: 'content_libraries.edit_library_content',
-  PUBLISH_LIBRARY_CONTENT: 'content_libraries.publish_library_content',
-  REUSE_LIBRARY_CONTENT: 'content_libraries.reuse_library_content',
-
-  CREATE_LIBRARY_COLLECTION: 'content_libraries.create_library_collection',
-  EDIT_LIBRARY_COLLECTION: 'content_libraries.edit_library_collection',
-  DELETE_LIBRARY_COLLECTION: 'content_libraries.delete_library_collection',
-
-  MANAGE_LIBRARY_TEAM: 'content_libraries.manage_library_team',
-  VIEW_LIBRARY_TEAM: 'content_libraries.view_library_team',
-};
-
-// Note: this information will eventually come from the backend API
-// but for the MVP we decided to manage it in the frontend
-export const libraryRolesMetadata: RoleMetadata[] = [
-  { role: 'library_admin', name: 'Library Admin', description: 'The Library Admin has full control over the library, including managing users, modifying content, and handling publishing workflows. They ensure content is properly maintained and accessible as needed.' },
-  { role: 'library_author', name: 'Library Author', description: 'The Library Author is responsible for creating, editing, and publishing content within a library. They can manage tags and collections but cannot delete libraries or manage users.' },
-  { role: 'library_contributor', name: 'Library Contributor', description: 'The Library Contributor can create and edit content within a library but cannot publish it. They support the authoring process while leaving final publishing to Authors or Admins.' },
-  { role: 'library_user', name: 'Library User', description: 'The Library User can view and reuse content but cannot edit or delete any resource.' },
-];
-
-export const libraryResourceTypes: ResourceMetadata[] = [
-  { key: 'library', label: 'Library', description: 'Permissions related to the library as a whole.' },
-  { key: 'library_content', label: 'Content', description: 'Permissions to create, edit, delete, and publish individual content items within the library.' },
-  { key: 'library_collection', label: 'Collection', description: 'Permissions to create, edit, and delete content collections within the library.' },
-  { key: 'library_team', label: 'Team', description: 'Permissions to manage user access and roles within the library.' },
-];
-
-export const libraryPermissions: PermissionMetadata[] = [
-  { key: CONTENT_LIBRARY_PERMISSIONS.DELETE_LIBRARY, resource: 'library', description: 'Allows the user to delete the library and all its contents.' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.MANAGE_LIBRARY_TAGS, resource: 'library', description: 'Add or remove tags from content.' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.VIEW_LIBRARY, resource: 'library', description: 'View content, search, filter, and sort within the library.' },
-
-  { key: CONTENT_LIBRARY_PERMISSIONS.EDIT_LIBRARY_CONTENT, resource: 'library_content', description: 'Edit content in draft mode' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.PUBLISH_LIBRARY_CONTENT, resource: 'library_content', description: 'Publish content, making it available for reuse' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.REUSE_LIBRARY_CONTENT, resource: 'library_content', description: 'Reuse published content within a course.' },
-
-  { key: CONTENT_LIBRARY_PERMISSIONS.CREATE_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Create new collections within a library.' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.EDIT_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Add or remove content from existing collections.' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.DELETE_LIBRARY_COLLECTION, resource: 'library_collection', description: 'Delete entire collections from the library.' },
-
-  { key: CONTENT_LIBRARY_PERMISSIONS.MANAGE_LIBRARY_TEAM, resource: 'library_team', description: 'View the list of users who have access to the library.' },
-  { key: CONTENT_LIBRARY_PERMISSIONS.VIEW_LIBRARY_TEAM, resource: 'library_team', description: 'Add, remove, and assign roles to users within the library.' },
-];
-
-export const DEFAULT_TOAST_DELAY = 5000;
-export const RETRY_TOAST_DELAY = 120_000; // 2 minutes
-export const SKELETON_ROWS = Array.from({ length: 10 }).map(() => ({
-  username: 'skeleton',
-  name: '',
-  email: '',
-  roles: [],
-}));
diff --git a/src/authz-module/libraries-manager/context.test.tsx b/src/authz-module/libraries-manager/context.test.tsx
index 8025e6cf..d004b906 100644
--- a/src/authz-module/libraries-manager/context.test.tsx
+++ b/src/authz-module/libraries-manager/context.test.tsx
@@ -5,7 +5,7 @@ import { useValidateUserPermissions } from '@src/data/hooks';
 import { renderWrapper } from '@src/setupTest';
 import { usePermissionsByRole } from '@src/authz-module/data/hooks';
 import { CustomErrors } from '@src/constants';
-import { CONTENT_LIBRARY_PERMISSIONS } from './constants';
+import { CONTENT_LIBRARY_PERMISSIONS } from '../constants';
 import { LibraryAuthZProvider, useLibraryAuthZ } from './context';
 
 jest.mock('react-router-dom', () => ({
diff --git a/src/authz-module/libraries-manager/context.tsx b/src/authz-module/libraries-manager/context.tsx
index 507e50b1..a6ad0035 100644
--- a/src/authz-module/libraries-manager/context.tsx
+++ b/src/authz-module/libraries-manager/context.tsx
@@ -9,7 +9,7 @@ import { PermissionMetadata, ResourceMetadata, Role } from 'types';
 import { CustomErrors } from '@src/constants';
 import {
   CONTENT_LIBRARY_PERMISSIONS, libraryPermissions, libraryResourceTypes, libraryRolesMetadata,
-} from './constants';
+} from '../constants';
 
 const LIBRARY_TEAM_PERMISSIONS = [
   CONTENT_LIBRARY_PERMISSIONS.VIEW_LIBRARY_TEAM,
diff --git a/src/authz-module/libraries-manager/messages.ts b/src/authz-module/libraries-manager/messages.ts
index 9ed3f7d4..f298761d 100644
--- a/src/authz-module/libraries-manager/messages.ts
+++ b/src/authz-module/libraries-manager/messages.ts
@@ -36,28 +36,28 @@ const messages = defineMessages({
     defaultMessage: '<Bold>Something went wrong on our end.</Bold> <Br></Br>Please try again later.',
     description: 'Libraries default error message',
   },
-  'library.authz.team.toast.500.error.message': {
-    id: 'library.authz.team.toast.500.error.message',
+  'authz.team.toast.500.error.message': {
+    id: 'authz.team.toast.500.error.message',
     defaultMessage: '<Bold>We\'re experiencing technical difficulties.</Bold> <Br></Br>Please try again later.',
-    description: 'Libraries internal server error message',
+    description: 'Internal server error message',
   },
-  'library.authz.team.toast.502.error.message': {
-    id: 'library.authz.team.toast.502.error.message',
+  'authz.team.toast.502.error.message': {
+    id: 'authz.team.toast.502.error.message',
     defaultMessage: '<Bold>We\'re having trouble connecting to our services.</Bold> <Br></Br>Please try again later.',
-    description: 'Libraries bad getaway error message',
+    description: 'Bad gateway error message',
   },
-  'library.authz.team.toast.503.error.message': {
-    id: 'library.authz.team.toast.503.error.message',
+  'authz.team.toast.503.error.message': {
+    id: 'authz.team.toast.503.error.message',
     defaultMessage: '<Bold>The service is temporarily unavailable.</Bold> <Br></Br>Please try again in a few moments.',
-    description: 'Libraries service temporary unabailable message',
+    description: 'Service temporarily unavailable message',
   },
-  'library.authz.team.toast.408.error.message': {
-    id: 'library.authz.team.toast.408.error.message',
+  'authz.team.toast.408.error.message': {
+    id: 'authz.team.toast.408.error.message',
     defaultMessage: '<Bold>The request took too long.</Bold> <Br></Br>Please check your connection and try again.',
-    description: 'Libraries request timeout message',
+    description: 'Request timeout message',
   },
-  'library.authz.team.toast.retry.label': {
-    id: 'library.authz.team.toast.retry.label',
+  'authz.team.toast.retry.label': {
+    id: 'authz.team.toast.retry.label',
     defaultMessage: 'Retry',
     description: 'Label for retry button.',
   },
diff --git a/src/authz-module/messages.ts b/src/authz-module/messages.ts
new file mode 100644
index 00000000..3b3916f6
--- /dev/null
+++ b/src/authz-module/messages.ts
@@ -0,0 +1,53 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages(
+  {
+    'authz.management.home.nav.link': {
+      id: 'authz.management.home.nav.link',
+      defaultMessage: 'Roles and Permissions Management',
+      description: 'Text for the roles and permissions management home page title navigation link',
+    },
+    'authz.management.assign.role.title': {
+      id: 'authz.management.assign.role.title',
+      defaultMessage: 'Assign Role',
+      description: 'Text for the assign role button',
+    },
+    'authz.team.toast.default.error.message': {
+      id: 'authz.team.toast.default.error.message',
+      defaultMessage: '<Bold>Something went wrong on our end.</Bold> <Br></Br>Please try again later.',
+      description: 'Default error message',
+    },
+    'authz.team.remove.user.toast.success.description': {
+      id: 'authz.team.remove.user.toast.success.description',
+      defaultMessage: 'The {role} role has been successfully removed.{rolesCount, plural, =0 { The user no longer has access to this library and has been removed from the member list.} other {}}',
+      description: 'Team management remove user toast success',
+    },
+    'authz.team.toast.500.error.message': {
+      id: 'authz.team.toast.500.error.message',
+      defaultMessage: '<Bold>We\'re experiencing technical difficulties.</Bold> <Br></Br>Please try again later.',
+      description: 'Internal server error message',
+    },
+    'authz.team.toast.502.error.message': {
+      id: 'authz.team.toast.502.error.message',
+      defaultMessage: '<Bold>We\'re having trouble connecting to our services.</Bold> <Br></Br>Please try again later.',
+      description: 'Bad gateway error message',
+    },
+    'authz.team.toast.503.error.message': {
+      id: 'authz.team.toast.503.error.message',
+      defaultMessage: '<Bold>The service is temporarily unavailable.</Bold> <Br></Br>Please try again in a few moments.',
+      description: 'Service temporarily unavailable message',
+    },
+    'authz.team.toast.408.error.message': {
+      id: 'authz.team.toast.408.error.message',
+      defaultMessage: '<Bold>The request took too long.</Bold> <Br></Br>Please check your connection and try again.',
+      description: 'Request timeout message',
+    },
+    'authz.team.toast.retry.label': {
+      id: 'authz.team.toast.retry.label',
+      defaultMessage: 'Retry',
+      description: 'Label for retry button.',
+    },
+  },
+);
+
+export default messages;
diff --git a/src/authz-module/roles-permissions/libraries/messages.ts b/src/authz-module/roles-permissions/libraries/messages.ts
index bada55fd..edbfae66 100644
--- a/src/authz-module/roles-permissions/libraries/messages.ts
+++ b/src/authz-module/roles-permissions/libraries/messages.ts
@@ -61,28 +61,28 @@ const messages = defineMessages({
     defaultMessage: '<Bold>Something went wrong on our end.</Bold> <Br></Br>Please try again later.',
     description: 'Libraries default error message',
   },
-  'library.authz.team.toast.500.error.message': {
-    id: 'library.authz.team.toast.500.error.message',
+  'authz.team.toast.500.error.message': {
+    id: 'authz.team.toast.500.error.message',
     defaultMessage: '<Bold>We\'re experiencing technical difficulties.</Bold> <Br></Br>Please try again later.',
-    description: 'Libraries internal server error message',
+    description: 'Internal server error message',
   },
-  'library.authz.team.toast.502.error.message': {
-    id: 'library.authz.team.toast.502.error.message',
+  'authz.team.toast.502.error.message': {
+    id: 'authz.team.toast.502.error.message',
     defaultMessage: '<Bold>We\'re having trouble connecting to our services.</Bold> <Br></Br>Please try again later.',
-    description: 'Libraries bad gateway error message',
+    description: 'Bad gateway error message',
   },
-  'library.authz.team.toast.503.error.message': {
-    id: 'library.authz.team.toast.503.error.message',
+  'authz.team.toast.503.error.message': {
+    id: 'authz.team.toast.503.error.message',
     defaultMessage: '<Bold>The service is temporarily unavailable.</Bold> <Br></Br>Please try again in a few moments.',
-    description: 'Libraries service temporary unavailable message',
+    description: 'Service temporarily unavailable message',
   },
-  'library.authz.team.toast.408.error.message': {
-    id: 'library.authz.team.toast.408.error.message',
+  'authz.team.toast.408.error.message': {
+    id: 'authz.team.toast.408.error.message',
     defaultMessage: '<Bold>The request took too long.</Bold> <Br></Br>Please check your connection and try again.',
-    description: 'Libraries request timeout message',
+    description: 'Request timeout message',
   },
-  'library.authz.team.toast.retry.label': {
-    id: 'library.authz.team.toast.retry.label',
+  'authz.team.toast.retry.label': {
+    id: 'authz.team.toast.retry.label',
     defaultMessage: 'Retry',
     description: 'Label for retry button.',
   },
diff --git a/src/data/api.ts b/src/data/api.ts
index b3d39531..c9289884 100644
--- a/src/data/api.ts
+++ b/src/data/api.ts
@@ -1,6 +1,8 @@
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import { PermissionValidationRequest, PermissionValidationResponse } from '@src/types';
+import { camelCaseObject } from '@edx/frontend-platform';
 import { getApiUrl } from './utils';
+import { UserAccount } from './types';
 
 export const validateUserPermissions = async (
   validations: PermissionValidationRequest[],
@@ -8,3 +10,9 @@ export const validateUserPermissions = async (
   const { data } = await getAuthenticatedHttpClient().post(getApiUrl('/api/authz/v1/permissions/validate/me'), validations);
   return data;
 };
+
+export const getUserAccount = async (username: string): Promise<UserAccount> => {
+  const url = new URL(getApiUrl(`/api/user/v1/accounts/${username}`));
+  const { data } = await getAuthenticatedHttpClient().get(url);
+  return camelCaseObject(data);
+};
diff --git a/src/data/hooks.test.tsx b/src/data/hooks.test.tsx
index 7dc20ec9..a2e284cc 100644
--- a/src/data/hooks.test.tsx
+++ b/src/data/hooks.test.tsx
@@ -2,7 +2,7 @@ import { act, ReactNode } from 'react';
 import { renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
-import { useValidateUserPermissions } from './hooks';
+import { useValidateUserPermissions, useUserAccount } from './hooks';
 
 jest.mock('@edx/frontend-platform/auth', () => ({
   getAuthenticatedHttpClient: jest.fn(),
@@ -42,6 +42,46 @@ const mockInvalidPermissions = [
   { action: 'act:read', object: 'lib:test-lib', allowed: false },
 ];
 
+const mockUserAccountData = {
+  username: 'john.doe',
+  bio: 'Software Developer',
+  accountPrivacy: 'public',
+  country: 'US',
+  dateJoined: '2023-01-15T10:30:00Z',
+  levelOfEducation: 'bachelor',
+  timeZone: 'America/New_York',
+  profileImage: {
+    hasImage: true,
+    imageUrlFull: 'https://example.com/profile_full.jpg',
+    imageUrlLarge: 'https://example.com/profile_large.jpg',
+    imageUrlMedium: 'https://example.com/profile_medium.jpg',
+    imageUrlSmall: 'https://example.com/profile_small.jpg',
+  },
+  courseCertificates: null,
+  languageProficiencies: [],
+  socialLinks: [],
+};
+
+const mockEmptyUserData = {
+  username: 'jane.smith',
+  bio: null,
+  accountPrivacy: 'private',
+  country: null,
+  dateJoined: '2023-06-20T14:15:00Z',
+  levelOfEducation: null,
+  timeZone: null,
+  profileImage: {
+    hasImage: false,
+    imageUrlFull: '',
+    imageUrlLarge: '',
+    imageUrlMedium: '',
+    imageUrlSmall: '',
+  },
+  courseCertificates: null,
+  languageProficiencies: [],
+  socialLinks: [],
+};
+
 describe('useValidateUserPermissions', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -95,3 +135,102 @@ describe('useValidateUserPermissions', () => {
     }
   });
 });
+
+describe('useUserAccount', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('fetches user account data successfully', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockResolvedValueOnce({ data: mockUserAccountData }),
+    });
+
+    const { result } = renderHook(() => useUserAccount('john.doe'), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(getAuthenticatedHttpClient).toHaveBeenCalled();
+    expect(result.current.data).toEqual(mockUserAccountData);
+    expect(result.current.data?.username).toBe('john.doe');
+  });
+
+  it('handles user account data with minimal information', async () => {
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockResolvedValueOnce({ data: mockEmptyUserData }),
+    });
+
+    const { result } = renderHook(() => useUserAccount('jane.smith'), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.username).toBe('jane.smith');
+    expect(result.current.data?.bio).toBeNull();
+    expect(result.current.data?.country).toBeNull();
+  });
+
+  it('handles API error gracefully', async () => {
+    const mockError = new Error('User not found');
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: jest.fn().mockRejectedValueOnce(mockError),
+    });
+
+    const { result } = renderHook(() => useUserAccount('nonexistent.user'), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+
+    expect(result.current.error).toEqual(mockError);
+    expect(result.current.data).toBeUndefined();
+  });
+
+  it('does not refetch on window focus', async () => {
+    const mockGet = jest.fn().mockResolvedValueOnce({ data: mockUserAccountData });
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: mockGet,
+    });
+
+    const { result } = renderHook(() => useUserAccount('john.doe'), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    act(() => {
+      window.dispatchEvent(new Event('focus'));
+    });
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates data when username changes', async () => {
+    const mockGet = jest.fn()
+      .mockResolvedValueOnce({ data: mockUserAccountData })
+      .mockResolvedValueOnce({ data: mockEmptyUserData });
+
+    (getAuthenticatedHttpClient as jest.Mock).mockReturnValue({
+      get: mockGet,
+    });
+
+    const { result, rerender } = renderHook(
+      ({ username }) => useUserAccount(username),
+      {
+        wrapper: createWrapper(),
+        initialProps: { username: 'john.doe' },
+      },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.username).toBe('john.doe');
+
+    rerender({ username: 'jane.smith' });
+
+    await waitFor(() => expect(result.current.data?.username).toBe('jane.smith'));
+    expect(mockGet).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/src/data/hooks.ts b/src/data/hooks.ts
index 80d4154e..833f1381 100644
--- a/src/data/hooks.ts
+++ b/src/data/hooks.ts
@@ -1,11 +1,12 @@
-import { useSuspenseQuery } from '@tanstack/react-query';
+import { useQuery, useSuspenseQuery } from '@tanstack/react-query';
 import { PermissionValidationRequest, PermissionValidationResponse } from '@src/types';
 import { appId } from '@src/constants';
-import { validateUserPermissions } from './api';
+import { getUserAccount, validateUserPermissions } from './api';
 
 const adminConsoleQueryKeys = {
   all: [appId] as const,
   permissions: (permissions: PermissionValidationRequest[]) => [...adminConsoleQueryKeys.all, 'validatePermissions', permissions] as const,
+  userAccount: (username: string) => [...adminConsoleQueryKeys.all, 'userAccount', username] as const,
 };
 
 /**
@@ -32,3 +33,11 @@ export const useValidateUserPermissions = (
   queryFn: () => validateUserPermissions(permissions),
   retry: false,
 });
+
+export const useUserAccount = (username: string) => useQuery({
+  queryKey: adminConsoleQueryKeys.userAccount(username),
+  queryFn: async () => getUserAccount(username),
+  retry: false,
+  enabled: !!username,
+  refetchOnWindowFocus: false,
+});
diff --git a/src/data/types.ts b/src/data/types.ts
new file mode 100644
index 00000000..81c51c5c
--- /dev/null
+++ b/src/data/types.ts
@@ -0,0 +1,39 @@
+export type ProfileImage = {
+  has_image: boolean;
+  image_url_full: string;
+  image_url_large: string;
+  image_url_medium: string;
+  image_url_small: string;
+};
+
+export type UserAccount = {
+  account_privacy: string;
+  profile_image: ProfileImage;
+  username: string;
+  bio: string | null;
+  course_certificates: unknown | null; // Type unclear from data
+  country: string | null;
+  date_joined: string; // ISO date string
+  language_proficiencies: unknown[]; // Array type unclear from empty data
+  level_of_education: string | null;
+  social_links: unknown[]; // Array type unclear from empty data
+  time_zone: string | null;
+  name: string;
+  email: string;
+  id: number;
+  verified_name: string | null;
+  extended_profile: unknown[]; // Array type unclear from empty data
+  gender: string | null;
+  state: string | null;
+  goals: string;
+  is_active: boolean;
+  last_login: string; // ISO date string
+  mailing_address: string;
+  requires_parental_consent: boolean;
+  secondary_email: string | null;
+  secondary_email_enabled: boolean | null;
+  year_of_birth: number | null;
+  phone_number: string | null;
+  activation_key: string;
+  pending_name_change: string | null;
+};
diff --git a/src/index.tsx b/src/index.tsx
index cbd7cf93..7e5ee477 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -6,7 +6,7 @@ import { AppProvider, ErrorPage } from '@edx/frontend-platform/react';
 import {
   APP_INIT_ERROR, APP_READY, subscribe, initialize, mergeConfig,
 } from '@edx/frontend-platform';
-import AuthZModule from 'authz-module';
+import AuthZModule from '@src/authz-module';
 
 import messages from './i18n';
 
diff --git a/src/types.ts b/src/types.ts
index 27d78f9f..215ef265 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -29,7 +29,9 @@ export interface RoleMetadata {
   name: string;
   description: string;
 }
+// TODO: remove unnecessary fields when libraries gets removed
 export interface Role extends RoleMetadata {
+  scope: string;
   userCount: number;
   permissions: string[];
   disabled?: boolean;
@@ -49,6 +51,13 @@ export type PermissionMetadata = {
   description?: string;
 };
 
+export type UserRole = {
+  role: string;
+  org: string;
+  scope: string;
+  permissionCount: number;
+};
+
 // Permissions Matrix
 
 export type EnrichedPermission = PermissionMetadata & {