diff --git a/apps/platform/trpc/routers/orgRouter/mail/emailIdentityRouter.ts b/apps/platform/trpc/routers/orgRouter/mail/emailIdentityRouter.ts
index 49b9941c..ecb8a938 100644
--- a/apps/platform/trpc/routers/orgRouter/mail/emailIdentityRouter.ts
+++ b/apps/platform/trpc/routers/orgRouter/mail/emailIdentityRouter.ts
@@ -8,8 +8,15 @@ import {
   teamMembers,
   spaces,
   emailIdentitiesAuthorizedSenders,
-  convos
+  convos,
+  spaceMembers
 } from '@u22n/database/schema';
+import {
+  inferTypeId,
+  typeIdGenerator,
+  typeIdValidator,
+  type TypeId
+} from '@u22n/utils/typeid';
 import {
   and,
   eq,
@@ -17,16 +24,11 @@ import {
   or,
   type InferInsertModel
 } from '@u22n/database/orm';
-import {
-  typeIdGenerator,
-  typeIdValidator,
-  type TypeId
-} from '@u22n/utils/typeid';
 import { router, orgProcedure, orgAdminProcedure } from '~platform/trpc/trpc';
-import { spaceMembers } from './../../../../../../packages/database/schema';
 import { emailIdentityExternalRouter } from './emailIdentityExternalRouter';
 import { nanoIdToken } from '@u22n/utils/zodSchemas';
 import { TRPCError } from '@trpc/server';
+import { db } from '@u22n/database';
 import { env } from '~platform/env';
 import { z } from 'zod';
 
@@ -333,8 +335,7 @@ export const emailIdentityRouter = router({
   getEmailIdentity: orgProcedure
     .input(
       z.object({
-        emailIdentityPublicId: typeIdValidator('emailIdentities'),
-        newEmailIdentity: z.boolean().optional()
+        emailIdentityPublicId: typeIdValidator('emailIdentities')
       })
     )
     .query(async ({ ctx, input }) => {
@@ -369,6 +370,8 @@ export const emailIdentityRouter = router({
             },
             authorizedSenders: {
               columns: {
+                // we need the id as there is no other way to key the authorizedSenders
+                id: true,
                 orgMemberId: true,
                 teamId: true,
                 spaceId: true
@@ -401,7 +404,10 @@ export const emailIdentityRouter = router({
                     publicId: true,
                     name: true,
                     description: true,
-                    color: true
+                    color: true,
+                    icon: true,
+                    type: true,
+                    personalSpace: true
                   }
                 }
               }
@@ -421,7 +427,17 @@ export const emailIdentityRouter = router({
                         avatarTimestamp: true,
                         name: true,
                         description: true,
-                        color: true
+                        color: true,
+                        icon: true,
+                        type: true
+                      },
+                      with: {
+                        personalSpaceOwner: {
+                          columns: {},
+                          with: {
+                            profile: true
+                          }
+                        }
                       }
                     },
                     team: {
@@ -746,5 +762,492 @@ export const emailIdentityRouter = router({
         emailIdentities: emailIdentities,
         defaultEmailIdentity: defaultEmailIdentityPublicId
       };
+    }),
+  setSendName: orgAdminProcedure
+    .input(
+      z.object({
+        emailIdentityPublicId: typeIdValidator('emailIdentities'),
+        sendName: z
+          .string()
+          .min(3, 'Send name must be at least 3 characters')
+          .max(64, 'Send name must be at most 64 characters')
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const emailIdentityResponse =
+        await ctx.db.query.emailIdentities.findFirst({
+          where: and(
+            eq(emailIdentities.publicId, input.emailIdentityPublicId),
+            eq(emailIdentities.orgId, ctx.org.id)
+          ),
+          columns: { id: true }
+        });
+
+      if (!emailIdentityResponse) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Email identity not found'
+        });
+      }
+
+      await db
+        .update(emailIdentities)
+        .set({
+          sendName: input.sendName
+        })
+        .where(eq(emailIdentities.id, emailIdentityResponse.id));
+    }),
+  addSender: orgAdminProcedure
+    .input(
+      z.object({
+        emailIdentityPublicId: typeIdValidator('emailIdentities'),
+        sender: z.union([
+          typeIdValidator('orgMembers'),
+          typeIdValidator('teams'),
+          typeIdValidator('spaces')
+        ])
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { db, org } = ctx;
+
+      const emailIdentityResponse = await db.query.emailIdentities.findFirst({
+        where: and(
+          eq(emailIdentities.publicId, input.emailIdentityPublicId),
+          eq(emailIdentities.orgId, org.id)
+        ),
+        columns: { id: true },
+        with: {
+          authorizedSenders: {
+            columns: {
+              id: true
+            },
+            with: {
+              orgMember: true,
+              team: true,
+              space: true
+            }
+          }
+        }
+      });
+
+      if (!emailIdentityResponse) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Email identity not found'
+        });
+      }
+
+      switch (inferTypeId(input.sender)) {
+        case 'orgMembers':
+          if (
+            emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.orgMember?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'CONFLICT',
+              message: 'Org member already has access'
+            });
+          }
+
+          const senderOrgMember = await db.query.orgMembers.findFirst({
+            where: eq(
+              orgMembers.publicId,
+              input.sender as TypeId<'orgMembers'>
+            ),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderOrgMember) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Org member not found'
+            });
+          }
+
+          await db.insert(emailIdentitiesAuthorizedSenders).values({
+            orgId: org.id,
+            identityId: emailIdentityResponse.id,
+            addedBy: org.memberId,
+            orgMemberId: senderOrgMember.id
+          });
+          return;
+        case 'teams':
+          if (
+            emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.team?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'CONFLICT',
+              message: 'Team already has access'
+            });
+          }
+          const senderTeam = await db.query.teams.findFirst({
+            where: eq(teams.publicId, input.sender as TypeId<'teams'>),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderTeam) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Team not found'
+            });
+          }
+          await db.insert(emailIdentitiesAuthorizedSenders).values({
+            orgId: org.id,
+            identityId: emailIdentityResponse.id,
+            addedBy: org.memberId,
+            teamId: senderTeam.id
+          });
+          return;
+        case 'spaces':
+          if (
+            emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.space?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'CONFLICT',
+              message: 'Space already has access'
+            });
+          }
+          const senderSpace = await db.query.spaces.findFirst({
+            where: eq(spaces.publicId, input.sender as TypeId<'spaces'>),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderSpace) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Space not found'
+            });
+          }
+          await db.insert(emailIdentitiesAuthorizedSenders).values({
+            orgId: org.id,
+            identityId: emailIdentityResponse.id,
+            addedBy: org.memberId,
+            spaceId: senderSpace.id
+          });
+          return;
+      }
+    }),
+  removeSender: orgAdminProcedure
+    .input(
+      z.object({
+        emailIdentityPublicId: typeIdValidator('emailIdentities'),
+        sender: z.union([
+          typeIdValidator('orgMembers'),
+          typeIdValidator('teams'),
+          typeIdValidator('spaces')
+        ])
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { db, org } = ctx;
+
+      const emailIdentityResponse = await db.query.emailIdentities.findFirst({
+        where: and(
+          eq(emailIdentities.publicId, input.emailIdentityPublicId),
+          eq(emailIdentities.orgId, org.id)
+        ),
+        columns: { id: true },
+        with: {
+          authorizedSenders: {
+            columns: {
+              id: true
+            },
+            with: {
+              orgMember: true,
+              team: true,
+              space: true
+            }
+          }
+        }
+      });
+
+      if (!emailIdentityResponse) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Email identity not found'
+        });
+      }
+
+      switch (inferTypeId(input.sender)) {
+        case 'orgMembers':
+          if (
+            !emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.orgMember?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Org member does not have access'
+            });
+          }
+          const senderOrgMember = await db.query.orgMembers.findFirst({
+            where: eq(
+              orgMembers.publicId,
+              input.sender as TypeId<'orgMembers'>
+            ),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderOrgMember) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Org member not found'
+            });
+          }
+          await db
+            .delete(emailIdentitiesAuthorizedSenders)
+            .where(
+              and(
+                eq(emailIdentitiesAuthorizedSenders.orgId, org.id),
+                eq(
+                  emailIdentitiesAuthorizedSenders.identityId,
+                  emailIdentityResponse.id
+                ),
+                eq(
+                  emailIdentitiesAuthorizedSenders.orgMemberId,
+                  senderOrgMember.id
+                )
+              )
+            );
+          return;
+        case 'teams':
+          if (
+            !emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.team?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Team does not have access'
+            });
+          }
+          const senderTeam = await db.query.teams.findFirst({
+            where: eq(teams.publicId, input.sender as TypeId<'teams'>),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderTeam) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Team not found'
+            });
+          }
+          await db
+            .delete(emailIdentitiesAuthorizedSenders)
+            .where(
+              and(
+                eq(emailIdentitiesAuthorizedSenders.orgId, org.id),
+                eq(
+                  emailIdentitiesAuthorizedSenders.identityId,
+                  emailIdentityResponse.id
+                ),
+                eq(emailIdentitiesAuthorizedSenders.teamId, senderTeam.id)
+              )
+            );
+          return;
+        case 'spaces':
+          if (
+            !emailIdentityResponse.authorizedSenders.some(
+              (sender) => sender.space?.publicId === input.sender
+            )
+          ) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Space does not have access'
+            });
+          }
+          const senderSpace = await db.query.spaces.findFirst({
+            where: eq(spaces.publicId, input.sender as TypeId<'spaces'>),
+            columns: {
+              id: true
+            }
+          });
+          if (!senderSpace) {
+            throw new TRPCError({
+              code: 'NOT_FOUND',
+              message: 'Space not found'
+            });
+          }
+          await db
+            .delete(emailIdentitiesAuthorizedSenders)
+            .where(
+              and(
+                eq(emailIdentitiesAuthorizedSenders.orgId, org.id),
+                eq(
+                  emailIdentitiesAuthorizedSenders.identityId,
+                  emailIdentityResponse.id
+                ),
+                eq(emailIdentitiesAuthorizedSenders.spaceId, senderSpace.id)
+              )
+            );
+          return;
+      }
+    }),
+  addDestination: orgAdminProcedure
+    .input(
+      z.object({
+        emailIdentityPublicId: typeIdValidator('emailIdentities'),
+        destination: typeIdValidator('spaces')
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { db, org } = ctx;
+
+      const emailIdentityResponse = await db.query.emailIdentities.findFirst({
+        where: and(
+          eq(emailIdentities.publicId, input.emailIdentityPublicId),
+          eq(emailIdentities.orgId, org.id)
+        ),
+        columns: { id: true },
+        with: {
+          routingRules: {
+            columns: { id: true },
+            with: {
+              destinations: {
+                columns: {
+                  publicId: true
+                },
+                with: {
+                  space: true
+                }
+              }
+            }
+          }
+        }
+      });
+
+      if (!emailIdentityResponse) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Email identity not found'
+        });
+      }
+
+      if (
+        emailIdentityResponse.routingRules.destinations.some(
+          (dest) => dest.space?.publicId === input.destination
+        )
+      ) {
+        throw new TRPCError({
+          code: 'CONFLICT',
+          message: 'Space is already a destination'
+        });
+      }
+
+      const spaceQuery = await db.query.spaces.findFirst({
+        where: eq(spaces.publicId, input.destination),
+        columns: {
+          id: true
+        }
+      });
+
+      if (!spaceQuery) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Space not found'
+        });
+      }
+
+      await db.insert(emailRoutingRulesDestinations).values({
+        orgId: org.id,
+        ruleId: emailIdentityResponse.routingRules.id,
+        spaceId: spaceQuery.id,
+        publicId: typeIdGenerator('emailRoutingRuleDestinations')
+      });
+    }),
+  removeDestination: orgAdminProcedure
+    .input(
+      z.object({
+        emailIdentityPublicId: typeIdValidator('emailIdentities'),
+        destination: typeIdValidator('spaces')
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { db, org } = ctx;
+
+      const emailIdentityResponse = await db.query.emailIdentities.findFirst({
+        where: and(
+          eq(emailIdentities.publicId, input.emailIdentityPublicId),
+          eq(emailIdentities.orgId, org.id)
+        ),
+        columns: { id: true },
+        with: {
+          routingRules: {
+            columns: { id: true },
+            with: {
+              destinations: {
+                columns: {
+                  publicId: true
+                },
+                with: {
+                  space: true
+                }
+              }
+            }
+          }
+        }
+      });
+
+      if (!emailIdentityResponse) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Email identity not found'
+        });
+      }
+
+      if (
+        !emailIdentityResponse.routingRules.destinations.some(
+          (dest) => dest.space?.publicId === input.destination
+        )
+      ) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Space is not a destination'
+        });
+      }
+
+      if (emailIdentityResponse.routingRules.destinations.length === 1) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Cannot remove last destination'
+        });
+      }
+
+      const spaceQuery = await db.query.spaces.findFirst({
+        where: eq(spaces.publicId, input.destination),
+        columns: {
+          id: true
+        }
+      });
+
+      if (!spaceQuery) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Space not found'
+        });
+      }
+      await db
+        .delete(emailRoutingRulesDestinations)
+        .where(
+          and(
+            eq(emailRoutingRulesDestinations.orgId, org.id),
+            eq(
+              emailRoutingRulesDestinations.ruleId,
+              emailIdentityResponse.routingRules.id
+            ),
+            eq(emailRoutingRulesDestinations.spaceId, spaceQuery.id)
+          )
+        );
     })
 });
diff --git a/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/[addressId]/page.tsx b/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/[addressId]/page.tsx
index a46058fc..d0dc7d08 100644
--- a/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/[addressId]/page.tsx
+++ b/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/[addressId]/page.tsx
@@ -1,29 +1,33 @@
 'use client';
 
 import {
-  Alert,
-  AlertDescription,
-  AlertTitle
-} from '@/src/components/shadcn-ui/alert';
-import { ArrowLeft, Info, SpinnerGap } from '@phosphor-icons/react';
+  ArrowLeft,
+  Check,
+  Pencil,
+  SpinnerGap,
+  SquaresFour
+} from '@phosphor-icons/react';
+import { Checkbox } from '@/src/components/shadcn-ui/checkbox';
+import { platform, type RouterOutputs } from '@/src/lib/trpc';
 import { Button } from '@/src/components/shadcn-ui/button';
 import { Badge } from '@/src/components/shadcn-ui/badge';
+import { Input } from '@/src/components/shadcn-ui/input';
 import { useOrgShortcode } from '@/src/hooks/use-params';
+import { useCallback, useMemo, useState } from 'react';
+import { Avatar } from '@/src/components/avatar';
 import { type TypeId } from '@u22n/utils/typeid';
-import { platform } from '@/src/lib/trpc';
+import { useParams } from 'next/navigation';
+import { toast } from 'sonner';
 import Link from 'next/link';
 
-export default function Page({
-  params
-}: {
-  params: { addressId: TypeId<'emailIdentities'> };
-}) {
+export default function Page() {
   const orgShortcode = useOrgShortcode();
+  const { addressId } = useParams<{ addressId: TypeId<'emailIdentities'> }>();
 
   const { data: emailInfo, isLoading } =
     platform.org.mail.emailIdentities.getEmailIdentity.useQuery({
       orgShortcode,
-      emailIdentityPublicId: params.addressId
+      emailIdentityPublicId: addressId
     });
 
   return (
@@ -39,20 +43,10 @@ export default function Page({
         </Button>
         <div className="flex flex-1 items-center">
           <h1 className="font-display text-2xl leading-5">
-            Edit Email Address
+            View Email Address
           </h1>
         </div>
       </div>
-      <Alert className="w-fit">
-        <Info className="size-4" />
-        <AlertTitle className="font-lg font-bold">
-          Sorry, Editing email addresses is not implemented yet.
-        </AlertTitle>
-        <AlertDescription>
-          We are actively working on everything. Please Contact support if you
-          need help.
-        </AlertDescription>
-      </Alert>
       {isLoading && (
         <div className="flex w-full justify-center gap-2 text-center font-bold">
           <SpinnerGap
@@ -63,64 +57,7 @@ export default function Page({
         </div>
       )}
       {emailInfo ? (
-        <>
-          <div>
-            <div className="text-base-11 font-bold uppercase">
-              Email Address
-            </div>
-            <div>
-              {`${emailInfo.emailIdentityData?.username}@${emailInfo.emailIdentityData?.domainName}`}
-            </div>
-          </div>
-          <div>
-            <div className="text-base-11 font-bold uppercase">
-              Forwarding Address
-            </div>
-            <div>
-              {emailInfo.emailIdentityData?.forwardingAddress ?? 'None'}
-            </div>
-          </div>
-          <div>
-            <div className="text-base-11 font-bold uppercase">Send Name</div>
-            <div>{emailInfo.emailIdentityData?.sendName ?? 'None'}</div>
-          </div>
-          <div>
-            <div className="text-base-11 font-bold uppercase">Catch All</div>
-            <div>
-              <Badge className="uppercase">
-                {emailInfo.emailIdentityData?.isCatchAll ? 'Yes' : 'No'}
-              </Badge>
-            </div>
-          </div>
-          <div>
-            <div className="text-base-11 font-bold uppercase">Delivers To</div>
-            <div className="flex flex-wrap gap-2">
-              {JSON.stringify(emailInfo.emailIdentityData?.routingRules)}
-              {/* {emailInfo.emailIdentityData?.authorizedSenders.map((member) => {
-                const profile = member.orgMember?.profile;
-                if (!profile) return null;
-                return (
-                  <div
-                    key={profile.publicId}
-                    className="bg-muted flex gap-2 rounded p-3">
-                    <Avatar
-                      avatarProfilePublicId={profile.publicId}
-                      avatarTimestamp={profile.avatarTimestamp}
-                      name={`${profile.firstName} ${profile.lastName}`}
-                      size="lg"
-                    />
-                    <div className="flex flex-col">
-                      <div>{`${profile.firstName} ${profile.lastName}`}</div>
-                      <div className="text-base-11 text-xs">
-                        @{profile.handle}
-                      </div>
-                    </div>
-                  </div>
-                );
-              })} */}
-            </div>
-          </div>
-        </>
+        <EmailInfo initialData={emailInfo} />
       ) : (
         !isLoading && (
           <div className="flex h-full flex-1 flex-col items-center justify-center gap-2">
@@ -136,3 +73,393 @@ export default function Page({
     </div>
   );
 }
+
+type InitialData =
+  RouterOutputs['org']['mail']['emailIdentities']['getEmailIdentity'];
+
+type EmailInfo = {
+  initialData: InitialData;
+};
+
+function EmailInfo({ initialData }: EmailInfo) {
+  return (
+    <>
+      <div>
+        <div className="text-base-11 font-bold uppercase">Email Address</div>
+        <div>
+          {`${initialData.emailIdentityData?.username}@${initialData.emailIdentityData?.domainName}`}
+        </div>
+      </div>
+      <div>
+        <div className="text-base-11 font-bold uppercase">
+          Forwarding Address
+        </div>
+        <div>{initialData.emailIdentityData?.forwardingAddress ?? 'None'}</div>
+      </div>
+      <div>
+        <div className="text-base-11 font-bold uppercase">Send Name</div>
+        <EditableSendName
+          name={initialData.emailIdentityData?.sendName ?? ''}
+          emailIdentityPublicId={initialData.emailIdentityData?.publicId}
+        />
+      </div>
+      <div>
+        <div className="text-base-11 font-bold uppercase">Catch All</div>
+        <div>
+          <Badge className="uppercase">
+            {initialData.emailIdentityData?.isCatchAll ? 'Yes' : 'No'}
+          </Badge>
+        </div>
+      </div>
+      <div>
+        <div className="text-base-11 font-bold uppercase">
+          Authorized Senders
+        </div>
+        <div className="flex flex-col gap-2 py-2">
+          <SenderList initialData={initialData} />
+        </div>
+      </div>
+      <div>
+        <div className="text-base-11 font-bold uppercase">Delivers To</div>
+        <div className="flex flex-col gap-2 py-2">
+          <DestinationList initialData={initialData} />
+        </div>
+      </div>
+    </>
+  );
+}
+
+function EditableSendName({
+  name,
+  emailIdentityPublicId
+}: {
+  name: string;
+  emailIdentityPublicId?: TypeId<'emailIdentities'>;
+}) {
+  const [editMode, setEditMode] = useState(false);
+  const [newName, setNewName] = useState(name);
+  const orgShortcode = useOrgShortcode();
+  const utils = platform.useUtils();
+
+  const { mutate: setSendName, isPending } =
+    platform.org.mail.emailIdentities.setSendName.useMutation({
+      onSuccess: () => {
+        void utils.org.mail.emailIdentities.getEmailIdentity.invalidate();
+        setEditMode(false);
+      }
+    });
+
+  return editMode ? (
+    <div className="flex items-center gap-2">
+      <Input
+        label="Send Name"
+        value={newName}
+        disabled={isPending}
+        onChange={(e) => setNewName(e.target.value)}
+      />
+      <Button
+        variant="ghost"
+        onClick={() => {
+          if (newName.trim() === '' || newName.trim() === name) {
+            setNewName(name);
+            setEditMode(false);
+          } else {
+            if (!emailIdentityPublicId)
+              return toast.error('Email identity not found');
+            setSendName({
+              orgShortcode,
+              emailIdentityPublicId,
+              sendName: newName
+            });
+          }
+        }}
+        loading={isPending}
+        size="icon">
+        <Check
+          size={16}
+          className="size-4"
+        />
+      </Button>
+    </div>
+  ) : (
+    <div className="flex gap-2">
+      <div>{name || 'None'}</div>
+      <Button
+        variant="outline"
+        onClick={() => setEditMode(true)}
+        size="icon-sm">
+        <Pencil
+          size={16}
+          className="size-4"
+        />
+      </Button>
+    </div>
+  );
+}
+
+function SenderList({ initialData }: { initialData: InitialData }) {
+  const orgShortcode = useOrgShortcode();
+  const utils = platform.useUtils();
+  const { data: spaces, isLoading } = platform.spaces.getAllOrgSpaces.useQuery({
+    orgShortcode
+  });
+  const { data: orgMembers } =
+    platform.org.users.members.getOrgMembersList.useQuery({ orgShortcode });
+  const { data: orgTeams } = platform.org.users.teams.getOrgTeams.useQuery({
+    orgShortcode
+  });
+
+  const clearCache = useCallback(() => {
+    void utils.org.mail.emailIdentities.getEmailIdentity.invalidate();
+    void utils.org.mail.emailIdentities.getOrgEmailIdentities.reset();
+    void utils.org.mail.emailIdentities.getUserEmailIdentities.reset();
+  }, [utils]);
+
+  const { mutate: addSender, isPending: isAdding } =
+    platform.org.mail.emailIdentities.addSender.useMutation({
+      onSuccess: () => clearCache()
+    });
+  const { mutate: removeSender, isPending: isRemoving } =
+    platform.org.mail.emailIdentities.removeSender.useMutation({
+      onSuccess: () => clearCache()
+    });
+
+  const senders = useMemo(
+    () =>
+      initialData.emailIdentityData?.authorizedSenders
+        .map(
+          (sender) =>
+            sender.space?.publicId ??
+            sender.orgMember?.publicId ??
+            sender.team?.publicId
+        )
+        .filter((id) => typeof id === 'string') ?? [],
+    [initialData.emailIdentityData?.authorizedSenders]
+  );
+
+  return isLoading ? (
+    <div className="flex items-center gap-2 text-center font-bold">
+      <SpinnerGap
+        className="size-4 animate-spin"
+        size={16}
+      />
+      Loading...
+    </div>
+  ) : (
+    <div className="flex flex-col gap-2">
+      <span className="text-base-11 text-xs font-bold uppercase">Spaces</span>
+      {spaces?.spaces.map((space) => (
+        <div
+          key={space.publicId}
+          className="flex items-center gap-2">
+          <Checkbox
+            disabled={isAdding || isRemoving}
+            checked={senders.includes(space.publicId)}
+            onCheckedChange={(checked) => {
+              if (!initialData.emailIdentityData) return;
+              if (checked) {
+                addSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: space.publicId
+                });
+              } else {
+                removeSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: space.publicId
+                });
+              }
+            }}
+          />
+          <div
+            className="flex size-6 min-h-6 min-w-6 items-center justify-center rounded-sm"
+            style={{
+              backgroundColor: `var(--${space.color}4)`,
+              color: `var(--${space.color}9)`
+            }}>
+            <SquaresFour
+              className="h-4 w-4"
+              weight="bold"
+            />
+          </div>
+          <span className="text-slate-12 h-full truncate font-medium">
+            {space.name}
+          </span>
+        </div>
+      ))}
+      <span className="text-base-11 text-xs font-bold uppercase">Teams</span>
+      {orgTeams?.teams.map((team) => (
+        <div
+          key={team.publicId}
+          className="flex items-center gap-2">
+          <Checkbox
+            disabled={isAdding || isRemoving}
+            checked={senders.includes(team.publicId)}
+            onCheckedChange={(checked) => {
+              if (!initialData.emailIdentityData) return;
+              if (checked) {
+                addSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: team.publicId
+                });
+              } else {
+                removeSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: team.publicId
+                });
+              }
+            }}
+          />
+          <Avatar
+            name={team.name}
+            avatarProfilePublicId={team.publicId}
+            avatarTimestamp={team.avatarTimestamp}
+            size="md"
+            hideTooltip
+          />
+          <span className="text-slate-12 h-full truncate font-medium">
+            {team.name}
+          </span>
+        </div>
+      ))}
+      <span className="text-base-11 text-xs font-bold uppercase">
+        Org Member
+      </span>
+      {orgMembers?.members?.map((orgMember) => (
+        <div
+          key={orgMember.publicId}
+          className="flex items-center gap-2">
+          <Checkbox
+            disabled={isAdding || isRemoving}
+            checked={senders.includes(orgMember.publicId)}
+            onCheckedChange={(checked) => {
+              if (!initialData.emailIdentityData) return;
+              if (checked) {
+                addSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: orgMember.publicId
+                });
+              } else {
+                removeSender({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  sender: orgMember.publicId
+                });
+              }
+            }}
+          />
+          <Avatar
+            name={`${orgMember.profile.firstName ?? orgMember.profile.handle} ${orgMember.profile.lastName ?? ''}`.trim()}
+            avatarProfilePublicId={orgMember.profile.publicId}
+            avatarTimestamp={orgMember.profile.avatarTimestamp}
+            size="md"
+            hideTooltip
+          />
+          <span className="text-slate-12 h-full truncate font-medium">
+            {`${orgMember.profile.firstName ?? orgMember.profile.handle} ${orgMember.profile.lastName ?? ''}`.trim()}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function DestinationList({ initialData }: { initialData: InitialData }) {
+  const orgShortcode = useOrgShortcode();
+  const utils = platform.useUtils();
+  const { data: spaces, isLoading } = platform.spaces.getAllOrgSpaces.useQuery({
+    orgShortcode
+  });
+
+  const destinations = useMemo(
+    () =>
+      initialData.emailIdentityData?.routingRules.destinations
+        .map((destination) => destination.space?.publicId)
+        .filter((id) => typeof id === 'string') ?? [],
+    [initialData.emailIdentityData?.routingRules.destinations]
+  );
+
+  const clearCache = useCallback(() => {
+    void utils.org.mail.emailIdentities.getEmailIdentity.invalidate();
+    void utils.org.mail.emailIdentities.getOrgEmailIdentities.reset();
+    void utils.org.mail.emailIdentities.getUserEmailIdentities.reset();
+  }, [utils]);
+
+  const { mutate: addDestination, isPending: isAdding } =
+    platform.org.mail.emailIdentities.addDestination.useMutation({
+      onSuccess: () => clearCache()
+    });
+  const { mutate: removeDestination, isPending: isRemoving } =
+    platform.org.mail.emailIdentities.removeDestination.useMutation({
+      onSuccess: () => clearCache()
+    });
+
+  return isLoading ? (
+    <div className="flex items-center gap-2 text-center font-bold">
+      <SpinnerGap
+        className="size-4 animate-spin"
+        size={16}
+      />
+      Loading...
+    </div>
+  ) : (
+    <div className="flex flex-col gap-2">
+      {spaces?.spaces.map((space) => (
+        <div
+          key={space.publicId}
+          className="flex items-center gap-2">
+          <Checkbox
+            disabled={
+              isAdding ||
+              isRemoving ||
+              (destinations.length === 1 && destinations[0] === space.publicId)
+            }
+            checked={destinations.includes(space.publicId)}
+            onCheckedChange={(checked) => {
+              if (!initialData.emailIdentityData) return;
+              if (checked) {
+                addDestination({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  destination: space.publicId
+                });
+              } else {
+                removeDestination({
+                  orgShortcode,
+                  emailIdentityPublicId:
+                    initialData.emailIdentityData?.publicId,
+                  destination: space.publicId
+                });
+              }
+            }}
+          />
+          <div
+            className="flex size-6 min-h-6 min-w-6 items-center justify-center rounded-sm"
+            style={{
+              backgroundColor: `var(--${space.color}4)`,
+              color: `var(--${space.color}9)`
+            }}>
+            <SquaresFour
+              className="h-4 w-4"
+              weight="bold"
+            />
+          </div>
+          <span className="text-slate-12 h-full truncate font-medium">
+            {space.name}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/add/_components/spaceComboBox.tsx b/apps/web/src/app/[orgShortcode]/settings/org/mail/addresses/add/_components/spaceComboBox.tsx
deleted file mode 100644
index e69de29b..00000000
diff --git a/apps/web/src/components/avatar.tsx b/apps/web/src/components/avatar.tsx
index 38fe186d..eb31cf12 100644
--- a/apps/web/src/components/avatar.tsx
+++ b/apps/web/src/components/avatar.tsx
@@ -110,7 +110,7 @@ export const Avatar = React.memo(function Avatar(props: AvatarProps) {
         </AvatarShad>
       </TooltipTrigger>
       <TooltipContent className="flex flex-col gap-1">
-        {altText}
+        {props.tooltipOverride ?? altText}
         <AvatarIcon
           avatarProfilePublicId={props.avatarProfilePublicId}
           size="xs"