diff --git a/app/components/assets/custom-fields-inputs.tsx b/app/components/assets/custom-fields-inputs.tsx
index 86d4b6ffe..0e2e73cac 100644
--- a/app/components/assets/custom-fields-inputs.tsx
+++ b/app/components/assets/custom-fields-inputs.tsx
@@ -77,7 +77,7 @@ export default function AssetCustomFields({
           name={`cf-${field.id}`}
           disabled={disabled}
           defaultChecked={
-            getCustomFieldVal(field.id) === "true" || field.required
+            getCustomFieldVal(field.id) === "Yes" || field.required
           }
         />
         <label className="font-medium text-gray-700 lg:hidden">
diff --git a/app/components/workspace/users-actions-dropdown.tsx b/app/components/workspace/users-actions-dropdown.tsx
index 73a0d06f2..43e1c607f 100644
--- a/app/components/workspace/users-actions-dropdown.tsx
+++ b/app/components/workspace/users-actions-dropdown.tsx
@@ -14,6 +14,7 @@ import {
 } from "~/components/shared/dropdown";
 
 import { useControlledDropdownMenu } from "~/hooks/use-controlled-dropdown-menu";
+import type { UserFriendlyRoles } from "~/routes/_layout+/settings.team";
 import { isFormProcessing } from "~/utils/form";
 import { Button } from "../shared/button";
 import { Spinner } from "../shared/spinner";
@@ -26,6 +27,7 @@ export function TeamUsersActionsDropdown({
   email,
   isSSO,
   customTrigger,
+  role,
 }: {
   userId: User["id"] | null;
   inviteStatus: InviteStatuses;
@@ -34,6 +36,7 @@ export function TeamUsersActionsDropdown({
   email: string;
   isSSO: boolean;
   customTrigger?: (disabled: boolean) => ReactNode;
+  role: UserFriendlyRoles;
 }) {
   const fetcher = useFetcher();
   const disabled = isFormProcessing(fetcher.state);
@@ -85,6 +88,7 @@ export function TeamUsersActionsDropdown({
                 <input type="hidden" name="name" value={name} />
                 <input type="hidden" name="email" value={email} />
                 <input type="hidden" name="teamMemberId" value={teamMemberId} />
+                <input type="hidden" name="userFriendlyRole" value={role} />
                 <Button
                   type="submit"
                   variant="link"
diff --git a/app/hooks/use-sidebar-nav-items.tsx b/app/hooks/use-sidebar-nav-items.tsx
index 3cd0d6980..0020e4301 100644
--- a/app/hooks/use-sidebar-nav-items.tsx
+++ b/app/hooks/use-sidebar-nav-items.tsx
@@ -172,6 +172,11 @@ export function useSidebarNavItems() {
           to: "/settings/team/users",
           hidden: isPersonalOrganization,
         },
+        {
+          title: "Pending invites",
+          to: "/settings/team/invites",
+          hidden: isPersonalOrganization,
+        },
         {
           title: "Non-registered members",
           to: "/settings/team/nrm",
diff --git a/app/modules/invite/service.server.ts b/app/modules/invite/service.server.ts
index 1e3588ef9..76612a117 100644
--- a/app/modules/invite/service.server.ts
+++ b/app/modules/invite/service.server.ts
@@ -1,15 +1,19 @@
-import type { Invite, TeamMember } from "@prisma/client";
+import type { Invite, Organization, Prisma, TeamMember } from "@prisma/client";
 import { InviteStatuses } from "@prisma/client";
-import type { AppLoadContext } from "@remix-run/node";
+import type { AppLoadContext, LoaderFunctionArgs } from "@remix-run/node";
 import jwt from "jsonwebtoken";
 import { db } from "~/database/db.server";
 import { invitationTemplateString } from "~/emails/invite-template";
 import { sendEmail } from "~/emails/mail.server";
+import { organizationRolesMap } from "~/routes/_layout+/settings.team";
 import { INVITE_EXPIRY_TTL_DAYS } from "~/utils/constants";
+import { updateCookieWithPerPage } from "~/utils/cookies.server";
 import { sendNotification } from "~/utils/emitter/send-notification.server";
 import { INVITE_TOKEN_SECRET } from "~/utils/env";
 import type { ErrorLabel } from "~/utils/error";
 import { ShelfError, isLikeShelfError } from "~/utils/error";
+import { getCurrentSearchParams } from "~/utils/http.server";
+import { getParamsValues } from "~/utils/list";
 import { checkDomainSSOStatus, doesSSOUserExist } from "~/utils/sso.server";
 import { generateRandomCode, inviteEmailText } from "./helpers";
 import { createTeamMember } from "../team-member/service.server";
@@ -419,3 +423,114 @@ export async function checkUserAndInviteMatch({
     });
   }
 }
+
+/** Gets invites for settings.team.invites page */
+export async function getPaginatedAndFilterableSettingInvites({
+  organizationId,
+  request,
+}: {
+  organizationId: Organization["id"];
+  request: LoaderFunctionArgs["request"];
+}) {
+  const searchParams = getCurrentSearchParams(request);
+  const paramsValues = getParamsValues(searchParams);
+
+  const { page, perPageParam, search } = paramsValues;
+
+  const inviteStatus =
+    searchParams.get("inviteStatus") === "ALL"
+      ? null
+      : (searchParams.get("inviteStatus") as InviteStatuses);
+
+  const cookie = await updateCookieWithPerPage(request, perPageParam);
+  const { perPage } = cookie;
+
+  try {
+    const skip = page > 1 ? (page - 1) * perPage : 0;
+    const take = perPage >= 1 && perPage <= 100 ? perPage : 200;
+
+    const inviteWhere: Prisma.InviteWhereInput = {
+      organizationId,
+      status: InviteStatuses.PENDING,
+      inviteeEmail: { not: "" },
+    };
+
+    if (search) {
+      /** Or search the input against input user/teamMember */
+      inviteWhere.OR = [
+        {
+          inviteeTeamMember: {
+            name: { contains: search, mode: "insensitive" },
+          },
+        },
+        {
+          inviteeUser: {
+            OR: [
+              { firstName: { contains: search, mode: "insensitive" } },
+              { lastName: { contains: search, mode: "insensitive" } },
+            ],
+          },
+        },
+      ];
+    }
+
+    if (inviteStatus) {
+      inviteWhere.status = inviteStatus;
+    }
+
+    const [invites, totalItemsGrouped] = await Promise.all([
+      /** Get the invites */
+      db.invite.findMany({
+        where: inviteWhere,
+        distinct: ["inviteeEmail"],
+        skip,
+        take,
+        select: {
+          id: true,
+          teamMemberId: true,
+          inviteeEmail: true,
+          status: true,
+          inviteeTeamMember: { select: { name: true } },
+          roles: true,
+        },
+      }),
+
+      db.invite.groupBy({
+        by: ["inviteeEmail"],
+        where: inviteWhere,
+      }),
+    ]);
+
+    /**
+     * Create the same structure for the invites
+     */
+    const items = invites.map((invite) => ({
+      id: invite.id,
+      name: invite.inviteeTeamMember.name,
+      img: "/static/images/default_pfp.jpg",
+      email: invite.inviteeEmail,
+      status: invite.status,
+      role: organizationRolesMap[invite?.roles[0]],
+      userId: null,
+      sso: false,
+    }));
+    const totalItems = totalItemsGrouped.length;
+    const totalPages = Math.ceil(totalItems / perPage);
+
+    return {
+      page,
+      perPage,
+      totalPages,
+      search,
+      items,
+      totalItems,
+    };
+  } catch (cause) {
+    throw new ShelfError({
+      cause,
+      message: "Something went wrong while getting registered users",
+      additionalData: { organizationId },
+      label,
+    });
+  }
+}
diff --git a/app/modules/settings/service.server.ts b/app/modules/settings/service.server.ts
index 819932879..22f82909c 100644
--- a/app/modules/settings/service.server.ts
+++ b/app/modules/settings/service.server.ts
@@ -38,11 +38,6 @@ export async function getPaginatedAndFilterableSettingUsers({
 
   const { page, perPageParam, search } = paramsValues;
 
-  const inviteStatus =
-    searchParams.get("inviteStatus") === "ALL"
-      ? null
-      : (searchParams.get("inviteStatus") as InviteStatuses);
-
   const cookie = await updateCookieWithPerPage(request, perPageParam);
   const { perPage } = cookie;
 
@@ -54,12 +49,6 @@ export async function getPaginatedAndFilterableSettingUsers({
       organizationId,
     };
 
-    const inviteWhere: Prisma.InviteWhereInput = {
-      organizationId,
-      status: InviteStatuses.PENDING,
-      inviteeEmail: { not: "" },
-    };
-
     if (search) {
       /** Either search the input against organization's user */
       userOrganizationWhere.user = {
@@ -68,86 +57,33 @@ export async function getPaginatedAndFilterableSettingUsers({
           { lastName: { contains: search, mode: "insensitive" } },
         ],
       };
-
-      /** Or search the input against input user/teamMember */
-      inviteWhere.OR = [
-        {
-          inviteeTeamMember: {
-            name: { contains: search, mode: "insensitive" },
-          },
-        },
-        {
-          inviteeUser: {
-            OR: [
-              { firstName: { contains: search, mode: "insensitive" } },
-              { lastName: { contains: search, mode: "insensitive" } },
-            ],
-          },
-        },
-      ];
-    }
-
-    if (inviteStatus) {
-      Object.assign(userOrganizationWhere, {
-        user: {
-          receivedInvites: { some: { status: inviteStatus } },
-        },
-      });
-      inviteWhere.status = inviteStatus;
     }
 
-    /**
-     * We have to get the items from two different data models, so have to
-     * divide skip and take into two part to get equal items from each model
-     */
-    const finalSkip = skip / 2;
-    const finalTake = take / 2;
-
-    const [userMembers, invites, totalUserMembers, totalInvites] =
-      await Promise.all([
-        /** Get Users */
-        db.userOrganization.findMany({
-          where: userOrganizationWhere,
-          skip: finalSkip,
-          take: finalTake,
-          select: {
-            user: {
-              include: {
-                teamMembers: {
-                  where: { organizationId },
-                  include: {
-                    _count: {
-                      select: { custodies: true },
-                    },
+    const [userMembers, totalItems] = await Promise.all([
+      /** Get Users */
+      db.userOrganization.findMany({
+        where: userOrganizationWhere,
+        skip,
+        take,
+        select: {
+          user: {
+            include: {
+              teamMembers: {
+                where: { organizationId },
+                include: {
+                  _count: {
+                    select: { custodies: true },
                   },
                 },
               },
             },
-            roles: true,
-          },
-        }),
-        /** Get the invites */
-        db.invite.findMany({
-          where: inviteWhere,
-          distinct: ["inviteeEmail"],
-          skip: finalSkip,
-          take: finalTake,
-          select: {
-            id: true,
-            teamMemberId: true,
-            inviteeEmail: true,
-            status: true,
-            inviteeTeamMember: { select: { name: true } },
-            roles: true,
           },
-        }),
-        db.userOrganization.count({ where: userOrganizationWhere }),
+          roles: true,
+        },
+      }),
 
-        db.invite.groupBy({
-          by: ["inviteeEmail"],
-          where: inviteWhere,
-        }),
-      ]);
+      db.userOrganization.count({ where: userOrganizationWhere }),
+    ]);
 
     /**
      * Create a structure for the users org members and merge it with invites
@@ -167,23 +103,6 @@ export async function getPaginatedAndFilterableSettingUsers({
         custodies: um?.user?.teamMembers?.[0]?._count?.custodies || 0,
       }));
 
-    /**
-     * Create the same structure for the invites
-     */
-    for (const invite of invites) {
-      teamMembersWithUserOrInvite.push({
-        id: invite.id,
-        name: invite.inviteeTeamMember.name,
-        img: "/static/images/default_pfp.jpg",
-        email: invite.inviteeEmail,
-        status: invite.status,
-        role: organizationRolesMap[invite?.roles[0]],
-        userId: null,
-        sso: false,
-      });
-    }
-
-    const totalItems = totalUserMembers + totalInvites.length;
     const totalPages = Math.ceil(totalItems / perPage);
 
     return {
diff --git a/app/modules/user/utils.server.ts b/app/modules/user/utils.server.ts
index e380bd47f..ae849efe4 100644
--- a/app/modules/user/utils.server.ts
+++ b/app/modules/user/utils.server.ts
@@ -1,8 +1,10 @@
-import { InviteStatuses, OrganizationRoles } from "@prisma/client";
+import type { OrganizationRoles } from "@prisma/client";
+import { InviteStatuses } from "@prisma/client";
 import { json, redirect } from "@remix-run/node";
 import { z } from "zod";
 import { db } from "~/database/db.server";
 import { sendEmail } from "~/emails/mail.server";
+import { organizationRolesMap } from "~/routes/_layout+/settings.team";
 import { sendNotification } from "~/utils/emitter/send-notification.server";
 import { ShelfError } from "~/utils/error";
 import { data, parseData } from "~/utils/http.server";
@@ -169,12 +171,14 @@ export async function resolveUserAction(
         email: inviteeEmail,
         name: teamMemberName,
         teamMemberId,
+        userFriendlyRole,
       } = parseData(
         formData,
         z.object({
           email: z.string(),
           name: z.string(),
           teamMemberId: z.string(),
+          userFriendlyRole: z.string(),
         }),
         {
           additionalData: {
@@ -184,15 +188,53 @@ export async function resolveUserAction(
         }
       );
 
-      const invite = await createInvite({
-        organizationId,
-        inviteeEmail,
-        teamMemberName,
-        teamMemberId,
-        inviterId: userId,
-        roles: [OrganizationRoles.ADMIN],
-        userId,
-      });
+      /** Find the Role based on its user friendly name */
+      const role = Object.keys(organizationRolesMap).find(
+        (key) => organizationRolesMap[key] === userFriendlyRole
+      ) as OrganizationRoles | undefined;
+
+      if (!role) {
+        throw new ShelfError({
+          cause: null,
+          message: "Invalid role",
+          additionalData: { userFriendlyRole },
+          label: "Team",
+        });
+      }
+
+      /** Invalidate all previous invites for current user for current organization */
+
+      const [_invalidatedInvites, invite] = await Promise.all([
+        await db.invite
+          .updateMany({
+            where: {
+              inviteeEmail,
+              organizationId,
+            },
+            data: {
+              status: InviteStatuses.INVALIDATED,
+            },
+          })
+          .catch((cause) => {
+            throw new ShelfError({
+              cause,
+              message: "Failed to invalidate previous invites",
+              additionalData: { userId, organizationId, inviteeEmail },
+              label: "Team",
+            });
+          }),
+
+        /** Create a new invite, based on the prev invite's role */
+        createInvite({
+          organizationId,
+          inviteeEmail,
+          teamMemberName,
+          teamMemberId,
+          inviterId: userId,
+          roles: [role],
+          userId,
+        }),
+      ]);
 
       if (invite) {
         sendNotification({
diff --git a/app/routes/_layout+/settings.team.users.invite-user.tsx b/app/routes/_layout+/settings.team.invites.invite-user.tsx
similarity index 100%
rename from app/routes/_layout+/settings.team.users.invite-user.tsx
rename to app/routes/_layout+/settings.team.invites.invite-user.tsx
diff --git a/app/routes/_layout+/settings.team.invites.tsx b/app/routes/_layout+/settings.team.invites.tsx
new file mode 100644
index 000000000..e611c23de
--- /dev/null
+++ b/app/routes/_layout+/settings.team.invites.tsx
@@ -0,0 +1,267 @@
+import { useMemo } from "react";
+import type { InviteStatuses } from "@prisma/client";
+import type {
+  ActionFunctionArgs,
+  LoaderFunctionArgs,
+  MetaFunction,
+} from "@remix-run/node";
+import { json, Link, Outlet, redirect, useMatches } from "@remix-run/react";
+import ContextualModal from "~/components/layout/contextual-modal";
+import type { HeaderData } from "~/components/layout/header/types";
+import { List } from "~/components/list";
+import { ListContentWrapper } from "~/components/list/content-wrapper";
+import { Filters } from "~/components/list/filters";
+import { Button } from "~/components/shared/button";
+import { InfoTooltip } from "~/components/shared/info-tooltip";
+import { Td, Th } from "~/components/table";
+import { TeamUsersActionsDropdown } from "~/components/workspace/users-actions-dropdown";
+import { db } from "~/database/db.server";
+
+import { getPaginatedAndFilterableSettingInvites } from "~/modules/invite/service.server";
+import type { TeamMembersWithUserOrInvite } from "~/modules/settings/service.server";
+import { resolveUserAction } from "~/modules/user/utils.server";
+import { appendToMetaTitle } from "~/utils/append-to-meta-title";
+import { makeShelfError, ShelfError } from "~/utils/error";
+import { error } from "~/utils/http.server";
+import {
+  PermissionAction,
+  PermissionEntity,
+} from "~/utils/permissions/permission.data";
+import { requirePermission } from "~/utils/roles.server";
+import { tw } from "~/utils/tw";
+import type { RouteHandleWithName } from "./bookings";
+
+export async function loader({ request, context }: LoaderFunctionArgs) {
+  const authSession = context.getSession();
+  const { userId } = authSession;
+
+  try {
+    const { organizationId } = await requirePermission({
+      userId,
+      request,
+      entity: PermissionEntity.teamMember,
+      action: PermissionAction.read,
+    });
+
+    /** Get the organization */
+    const organization = await db.organization.findFirst({
+      where: { id: organizationId },
+      include: { owner: true },
+    });
+
+    if (!organization) {
+      throw new ShelfError({
+        cause: null,
+        message: "Organization not found",
+        additionalData: { organizationId, userId },
+        label: "Team",
+      });
+    }
+
+    /** Cannot manage users for PERSONAL organization */
+    if (organization?.type === "PERSONAL") {
+      return redirect("/settings/general");
+    }
+
+    const { page, perPage, search, items, totalItems, totalPages } =
+      await getPaginatedAndFilterableSettingInvites({
+        organizationId,
+        request,
+      });
+
+    const header: HeaderData = {
+      title: `Settings - ${organization.name}`,
+    };
+
+    const modelName = {
+      singular: "pending invite",
+      plural: "pending invites",
+    };
+
+    return {
+      header,
+      items,
+      totalItems,
+      page,
+      perPage,
+      search,
+      totalPages,
+      modelName,
+      organization,
+    };
+  } catch (cause) {
+    const reason = makeShelfError(cause, { userId });
+    throw json(error(reason), { status: reason.status });
+  }
+}
+
+export const meta: MetaFunction<typeof loader> = ({ data }) => [
+  { title: data ? appendToMetaTitle(data.header.title) : "" },
+];
+
+export async function action({ context, request }: ActionFunctionArgs) {
+  const authSession = context.getSession();
+  const { userId } = authSession;
+
+  try {
+    const { organizationId } = await requirePermission({
+      userId,
+      request,
+      entity: PermissionEntity.teamMember,
+      action: PermissionAction.update,
+    });
+
+    return await resolveUserAction(request, organizationId, userId);
+  } catch (cause) {
+    const reason = makeShelfError(cause, { userId });
+    return json(error(reason), { status: reason.status });
+  }
+}
+
+export const handle = {
+  name: "settings.team.users",
+  breadcrumb: () => <Link to="/settings/team">Team</Link>,
+};
+
+export default function UserInvitesSetting() {
+  /**
+   * We have 4 cases when we should render index:
+   * 1. When we are on the index route
+   * 2. When we are on the .new route - the reason we do this is because we want to have the .new modal overlaying the index.
+   * 3. When we are on the assets.$assetId.bookings page
+   * 4. When we are on the settings.team.users.$userId.bookings
+   */
+  const matches = useMatches();
+  const currentRoute: RouteHandleWithName = matches[matches.length - 1];
+  const allowedRoutes = [
+    "settings.team.users", // users index
+    "settings.team.invites", // users index
+    "settings.team.users.invite-user", // invite user modal
+  ];
+
+  const shouldRenderIndex = allowedRoutes.includes(currentRoute?.handle?.name);
+
+  return shouldRenderIndex ? (
+    <div>
+      <ContextualModal />
+
+      <p className="mb-6 text-xs text-gray-600">
+        Users by default have a mail registered in shelf and can get reminders,
+        log in or perform other actions. Read more about our{" "}
+        <Link
+          to="https://www.shelf.nu/knowledge-base/user-roles-and-their-permissions"
+          target="_blank"
+          className="underline"
+        >
+          permissions here
+        </Link>
+        .
+      </p>
+
+      <ListContentWrapper>
+        <Filters>
+          <Button
+            variant="primary"
+            to="invite-user"
+            className="mt-2 w-full md:mt-0 md:w-max"
+          >
+            <span className=" whitespace-nowrap">Invite a user</span>
+          </Button>
+        </Filters>
+
+        <List
+          className="overflow-x-visible md:overflow-x-auto"
+          ItemComponent={UserRow}
+          headerChildren={
+            <>
+              <Th>
+                <div className="flex items-center gap-1 [&_svg]:size-[15px]">
+                  Custodies{" "}
+                  <InfoTooltip content="Custodies count includes only direct asset custodies and doesn't count any assets assigned via bookings." />
+                </div>
+              </Th>
+              <Th>Role</Th>
+              <Th>Status</Th>
+              <Th>Actions</Th>
+            </>
+          }
+        />
+      </ListContentWrapper>
+    </div>
+  ) : (
+    <Outlet />
+  );
+}
+
+function UserRow({ item }: { item: TeamMembersWithUserOrInvite }) {
+  return (
+    <>
+      <Td className="w-full whitespace-normal p-0 md:p-0">
+        <TeamMemberDetails details={item} />
+      </Td>
+      <Td>{item.custodies || 0}</Td>
+      <Td>{item.role}</Td>
+      <Td>
+        <InviteStatusBadge status={item.status} />
+      </Td>
+      <Td className="text-right">
+        {item.role !== "Owner" ? (
+          <TeamUsersActionsDropdown
+            inviteStatus={item.status}
+            userId={item.userId}
+            name={item.name}
+            email={item.email} // In this case we can assume that inviteeEmail is defined because we only render this dropdown for existing users
+            isSSO={item.sso || false}
+            role={item.role}
+          />
+        ) : null}
+      </Td>
+    </>
+  );
+}
+
+const InviteStatusBadge = ({ status }: { status: InviteStatuses }) => {
+  const colorClasses = useMemo(() => {
+    switch (status) {
+      case "PENDING":
+        return "bg-gray-200 text-gray-700";
+      case "ACCEPTED":
+        return "bg-success-50 text-success-700";
+      case "REJECTED":
+        return "bg-error-50 text-error-700";
+      default:
+        return "bg-gray-200 text-gray-700";
+    }
+  }, [status]);
+
+  return (
+    <span
+      className={tw(
+        "inline-flex justify-center rounded-2xl bg-gray-100 px-2 py-[2px] text-center text-[12px] font-medium text-gray-700",
+        colorClasses
+      )}
+    >
+      <span>{status}</span>
+    </span>
+  );
+};
+
+const TeamMemberDetails = ({
+  details,
+}: {
+  details: TeamMembersWithUserOrInvite;
+}) => (
+  <div className="flex justify-between gap-3 p-4 md:justify-normal md:px-6">
+    <div className="flex items-center gap-3">
+      <div className="flex size-12 shrink-0 items-center justify-center">
+        <img src={details.img} alt="custodian" className="size-10 rounded" />
+      </div>
+      <div className="min-w-[130px]">
+        <span className="word-break mb-1 block font-medium">
+          {details.name}
+        </span>
+        <div>{details.email}</div>
+      </div>
+    </div>
+  </div>
+);
diff --git a/app/routes/_layout+/settings.team.tsx b/app/routes/_layout+/settings.team.tsx
index 192aa0ad7..576624554 100644
--- a/app/routes/_layout+/settings.team.tsx
+++ b/app/routes/_layout+/settings.team.tsx
@@ -52,7 +52,12 @@ export default function TeamSettings() {
   const { isPersonalOrg, orgName } = useLoaderData<typeof loader>();
 
   const TABS: Item[] = [
-    ...(!isPersonalOrg ? [{ to: "users", content: "Users" }] : []),
+    ...(!isPersonalOrg
+      ? [
+          { to: "users", content: "Users" },
+          { to: "invites", content: "Invites" },
+        ]
+      : []),
     { to: "nrm", content: "Non-registered members" },
   ];
 
@@ -61,7 +66,7 @@ export default function TeamSettings() {
   return (
     <>
       <When truthy={!params.userId}>
-        <div className="h-full rounded border bg-white p-4 md:px-10 md:py-8">
+        <div className="rounded border bg-white p-4 md:px-10 md:py-8">
           <h1 className="text-[18px] font-semibold">
             {isPersonalOrg ? "Team" : `${orgName}’s team`}
           </h1>
diff --git a/app/routes/_layout+/settings.team.users.$userId.tsx b/app/routes/_layout+/settings.team.users.$userId.tsx
index 77520b80f..466341d69 100644
--- a/app/routes/_layout+/settings.team.users.$userId.tsx
+++ b/app/routes/_layout+/settings.team.users.$userId.tsx
@@ -166,6 +166,7 @@ export default function UserPage() {
                 Actions
               </Button>
             )}
+            role={userOrgRole}
           />
         </AbsolutePositionedHeaderActions>
       </When>
diff --git a/app/routes/_layout+/settings.team.users.tsx b/app/routes/_layout+/settings.team.users.tsx
index 11ae2ef26..6fc5e3e70 100644
--- a/app/routes/_layout+/settings.team.users.tsx
+++ b/app/routes/_layout+/settings.team.users.tsx
@@ -6,7 +6,6 @@ import type {
   MetaFunction,
 } from "@remix-run/node";
 import { json, Link, Outlet, redirect, useMatches } from "@remix-run/react";
-import { StatusFilter } from "~/components/booking/status-filter";
 import ContextualModal from "~/components/layout/contextual-modal";
 import type { HeaderData } from "~/components/layout/header/types";
 import { List } from "~/components/list";
@@ -119,11 +118,6 @@ export async function action({ context, request }: ActionFunctionArgs) {
   }
 }
 
-const STATUS_FILTERS = {
-  PENDING: "PENDING",
-  ACCEPTED: "ACCEPTED",
-};
-
 export const handle = {
   name: "settings.team.users",
   breadcrumb: () => <Link to="/settings/team">Team</Link>,
@@ -164,16 +158,10 @@ export default function UserTeamSetting() {
       </p>
 
       <ListContentWrapper>
-        <Filters
-          slots={{
-            "left-of-search": (
-              <StatusFilter statusItems={STATUS_FILTERS} name="inviteStatus" />
-            ),
-          }}
-        >
+        <Filters>
           <Button
             variant="primary"
-            to="invite-user"
+            to="../invites/invite-user"
             className="mt-2 w-full md:mt-0 md:w-max"
           >
             <span className=" whitespace-nowrap">Invite a user</span>
@@ -229,6 +217,7 @@ function UserRow({ item }: { item: TeamMembersWithUserOrInvite }) {
             name={item.name}
             email={item.email} // In this case we can assume that inviteeEmail is defined because we only render this dropdown for existing users
             isSSO={item.sso || false}
+            role={item.role}
           />
         ) : null}
       </Td>
diff --git a/app/utils/csv.server.ts b/app/utils/csv.server.ts
index 082acba42..69cc295e1 100644
--- a/app/utils/csv.server.ts
+++ b/app/utils/csv.server.ts
@@ -55,7 +55,7 @@ export const parseCsv = (csvData: ArrayBuffer) => {
   const csv = iconv.decode(Buffer.from(csvData), encoding || "utf-8");
   const delimiter = guessDelimiters(csv, [",", ";"]);
 
-  return new Promise((resolve, reject) => {
+  return new Promise<CSVData>((resolve, reject) => {
     const parser = parse({
       encoding: "utf-8", // Set encoding to utf-8
       delimiter, // Set delimiter
@@ -95,7 +95,7 @@ export const csvDataFromRequest = async ({ request }: { request: Request }) => {
 
     const csvData = await csvFile.arrayBuffer();
 
-    return (await parseCsv(csvData)) as CSVData;
+    return await parseCsv(csvData);
   } catch (cause) {
     throw new ShelfError({
       cause,
diff --git a/app/utils/custom-fields.ts b/app/utils/custom-fields.ts
index dea01eede..0537ebc94 100644
--- a/app/utils/custom-fields.ts
+++ b/app/utils/custom-fields.ts
@@ -168,8 +168,11 @@ export const buildCustomFieldValue = (
     }
 
     switch (def.type) {
-      case "BOOLEAN":
-        return { raw, valueBoolean: Boolean(raw) };
+      case "BOOLEAN": {
+        const finalValue =
+          typeof raw === "string" ? raw === "yes" : Boolean(raw);
+        return { raw, valueBoolean: finalValue };
+      }
       case "DATE": {
         // Store raw date as entered by user
         // But format valueDate as ISO string with UTC midnight to satisfy DB constraint