diff --git a/apps/dashboard/src/app/(internal)/brukere/queries.ts b/apps/dashboard/src/app/(internal)/brukere/queries.ts
index fafa0c1dff..f93cdb3296 100644
--- a/apps/dashboard/src/app/(internal)/brukere/queries.ts
+++ b/apps/dashboard/src/app/(internal)/brukere/queries.ts
@@ -16,13 +16,16 @@ interface UseUserAllQueryProps {
   page?: Pageable
 }
 
-export const useUserAllQuery = ({ filter, page }: UseUserAllQueryProps) => {
+export const useUserAllQuery = ({ filter, page }: UseUserAllQueryProps, options?: Parameters<typeof useQuery>[2]) => {
   const trpc = useTRPC()
   const { data, isLoading } = useQuery(
-    trpc.user.all.queryOptions({
-      filter,
-      ...page,
-    })
+    trpc.user.all.queryOptions(
+      {
+        filter,
+        ...page,
+      },
+      options
+    )
   )
   return { users: useMemo(() => data?.items ?? [], [data]), isLoading }
 }
diff --git a/apps/dashboard/src/app/(internal)/varslinger/[id]/edit-card.tsx b/apps/dashboard/src/app/(internal)/varslinger/[id]/edit-card.tsx
index 19b907292c..22866696c4 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/[id]/edit-card.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/[id]/edit-card.tsx
@@ -2,6 +2,7 @@ import type { FC } from "react"
 import { useEditNotificationMutation } from "../mutations"
 import { useNotificationWriteForm } from "../write-form"
 import { useNotificationDetailsContext } from "./provider"
+
 export const NotificationEditCard: FC = () => {
   const { notification } = useNotificationDetailsContext()
   const edit = useEditNotificationMutation()
@@ -10,9 +11,9 @@ export const NotificationEditCard: FC = () => {
     label: "Oppdater varsling",
     onSubmit: (data) => {
       const { ...notificationData } = data
-      edit.mutate({ id: notification.id, input: notificationData})
+      edit.mutate({ id: notification.id, input: notificationData })
     },
-    defaultValues: { ...notification  }
+    defaultValues: { ...notification },
   })
   return <FormComponent />
 }
diff --git a/apps/dashboard/src/app/(internal)/varslinger/[id]/layout.tsx b/apps/dashboard/src/app/(internal)/varslinger/[id]/layout.tsx
index 9764e9a6f5..68237812ec 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/[id]/layout.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/[id]/layout.tsx
@@ -1,4 +1,5 @@
 "use client"
+
 import { Loader } from "@mantine/core"
 import { type PropsWithChildren, use, useMemo } from "react"
 import { NotificationDetailsContext } from "./provider"
diff --git a/apps/dashboard/src/app/(internal)/varslinger/[id]/provider.tsx b/apps/dashboard/src/app/(internal)/varslinger/[id]/provider.tsx
index 96a7656e1c..0b38dae6c6 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/[id]/provider.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/[id]/provider.tsx
@@ -1,7 +1,7 @@
 "use client"
 
-import type { Notification } from "@dotkomonline/types"
 import { createContext, useContext } from "react"
+import type { Notification } from "@dotkomonline/rpc"
 
 export const NotificationDetailsContext = createContext<{
   notification: Notification
diff --git a/apps/dashboard/src/app/(internal)/varslinger/all-notification-table.tsx b/apps/dashboard/src/app/(internal)/varslinger/all-notification-table.tsx
index dc30fd0ad9..7b4984cbc2 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/all-notification-table.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/all-notification-table.tsx
@@ -3,8 +3,8 @@ import { Anchor } from "@mantine/core"
 import { createColumnHelper, getCoreRowModel, useReactTable } from "@tanstack/react-table"
 import Link from "next/link"
 import { useMemo } from "react"
-import { mapNotificationPayloadTypeToLabel, mapNotificationTypeToLabel, Notification } from "node_modules/@dotkomonline/rpc/src/modules/notification/notification"
 import { DateTooltip } from "@/components/DateTooltip"
+import { mapNotificationPayloadTypeToLabel, mapNotificationTypeToLabel, type Notification } from "@dotkomonline/rpc"
 
 interface AllNotificationsTableProps {
   notifications: Notification[]
@@ -25,7 +25,7 @@ export const AllNotificationsTable = ({ notifications }: AllNotificationsTablePr
         ),
       }),
 
-     columnHelper.accessor((notification) => notification.shortDescription, {
+      columnHelper.accessor((notification) => notification.shortDescription, {
         id: "shortDescription",
         header: () => "Kort beskrivelse",
         cell: (info) => info.getValue(),
@@ -52,7 +52,6 @@ export const AllNotificationsTable = ({ notifications }: AllNotificationsTablePr
       }),
     ],
     [columnHelper]
-    
   )
 
   const tableOptions = useMemo(
@@ -65,9 +64,5 @@ export const AllNotificationsTable = ({ notifications }: AllNotificationsTablePr
   )
 
   const table = useReactTable(tableOptions)
-  return (
-    <GenericTable
-      table = {table} 
-    />
-  )
+  return <GenericTable table={table} />
 }
diff --git a/apps/dashboard/src/app/(internal)/varslinger/modals/create-notification.tsx b/apps/dashboard/src/app/(internal)/varslinger/modals/create-notification.tsx
index bf1384fa09..48ee29beeb 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/modals/create-notification.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/modals/create-notification.tsx
@@ -8,10 +8,7 @@ export const CreateNotificationModal: FC<ContextModalProps> = ({ context, id })
   const create = useCreateNotificationMutation()
   const FormComponent = useNotificationWriteForm({
     onSubmit: (data) => {
-      create.mutate(
-        data
-      ),
-      close()
+      create.mutate(data), close()
     },
   })
   return <FormComponent />
diff --git a/apps/dashboard/src/app/(internal)/varslinger/mutations.ts b/apps/dashboard/src/app/(internal)/varslinger/mutations.ts
index 5663479974..b6f7ac1d20 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/mutations.ts
+++ b/apps/dashboard/src/app/(internal)/varslinger/mutations.ts
@@ -1,4 +1,3 @@
-import { env } from "@/lib/env"
 import { useQueryNotification } from "@/lib/notifications"
 import { useTRPC } from "@/lib/trpc-client"
 import { useMutation, useQueryClient } from "@tanstack/react-query"
@@ -16,8 +15,7 @@ export const useCreateNotificationMutation = () => {
         })
       },
       onSuccess: async (data) => {
-        await queryClient.invalidateQueries({ queryKey: trpc.notification.findMany.queryKey() });
-
+        await queryClient.invalidateQueries({ queryKey: trpc.notification.findMany.queryKey() })
 
         notification.complete({
           title: "Varsling opprettet",
@@ -64,4 +62,3 @@ export const useEditNotificationMutation = () => {
     })
   )
 }
-
diff --git a/apps/dashboard/src/app/(internal)/varslinger/page.tsx b/apps/dashboard/src/app/(internal)/varslinger/page.tsx
index c107ed80a0..e3e90c2a09 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/page.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/page.tsx
@@ -3,11 +3,10 @@
 import { Box, Button, Skeleton, Stack } from "@mantine/core"
 import { AllNotificationsTable } from "./all-notification-table"
 import { useCreateNotificationModal } from "./modals/create-notification"
-import { useNotificationAllQuery } from "./queries"
-
+import { useNotificationAllInfiniteQuery } from "./queries"
 
 export default function NotificationPage() {
-  const { notifications, isLoading: isNotificationsLoading } = useNotificationAllQuery()
+  const { notifications, isLoading: isNotificationsLoading } = useNotificationAllInfiniteQuery()
   const open = useCreateNotificationModal()
 
   return (
diff --git a/apps/dashboard/src/app/(internal)/varslinger/queries.ts b/apps/dashboard/src/app/(internal)/varslinger/queries.ts
index e20309fecc..8a5799187e 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/queries.ts
+++ b/apps/dashboard/src/app/(internal)/varslinger/queries.ts
@@ -1,12 +1,12 @@
 import { useTRPC } from "@/lib/trpc-client"
-import { Pageable } from "@dotkomonline/rpc"
+import type { Pageable } from "@dotkomonline/utils"
 import { useInfiniteQuery } from "@tanstack/react-query"
 import { useMemo } from "react"
 
-export const useNotificationAllQuery = (page?: Pageable) => {
+export const useNotificationAllInfiniteQuery = (page?: Pageable) => {
   const trpc = useTRPC()
 
-  const { data,  ...query } = useInfiniteQuery({
+  const { data, ...query } = useInfiniteQuery({
     ...trpc.notification.findMany.infiniteQueryOptions({ ...page }),
     getNextPageParam: (lastPage) => lastPage.nextCursor,
     select: (res) => res.pages.flatMap((p) => p.items),
@@ -14,5 +14,3 @@ export const useNotificationAllQuery = (page?: Pageable) => {
 
   return { notifications: useMemo(() => data ?? [], [data]), ...query }
 }
-
-
diff --git a/apps/dashboard/src/app/(internal)/varslinger/write-form.tsx b/apps/dashboard/src/app/(internal)/varslinger/write-form.tsx
index 48c379147f..e2acf087db 100644
--- a/apps/dashboard/src/app/(internal)/varslinger/write-form.tsx
+++ b/apps/dashboard/src/app/(internal)/varslinger/write-form.tsx
@@ -2,21 +2,23 @@ import { useFormBuilder } from "@/components/forms/Form"
 import { createRichTextInput } from "@/components/forms/RichTextInput/RichTextInput"
 import { createSelectInput } from "@/components/forms/SelectInput"
 import { createTextInput } from "@/components/forms/TextInput"
-import { mapNotificationPayloadTypeToLabel, mapNotificationTypeToLabel, NotificationPayloadTypeSchema, NotificationTypeSchema, NotificationWriteSchema } from "node_modules/@dotkomonline/rpc/src/modules/notification/notification"
-import { type z } from "zod"
+import type { z } from "zod"
 import { useGroupAllQuery } from "../grupper/queries"
+import { createSearchableSelectInput } from "@/components/forms/SearchableSelectInput"
+import { useUserSearch } from "@/components/forms/hooks/useUserSearch"
+import {
+  mapNotificationPayloadTypeToLabel,
+  mapNotificationTypeToLabel,
+  NotificationPayloadTypeSchema,
+  NotificationTypeSchema,
+  NotificationWriteSchema,
+} from "@dotkomonline/rpc"
 
-const NOTIFICATION_FORM_DATA_TYPE = Object.values(NotificationTypeSchema.Values).map((type) => ({
-  value: type,
-  label: mapNotificationTypeToLabel(type),
-}))
-
-const NOTIFICATION_FORM_DATA_PAYLOAD_TYPE = Object.values(NotificationPayloadTypeSchema.Values).map((type) => ({
-  value: type,
-  label: mapNotificationPayloadTypeToLabel(type),
-}))
-
-const NOTIFICATION_FORM_DEFAULT_VALUES: Partial<NotificationWriteFormSchema> = {recipientIds: [], taskId: null }
+const NOTIFICATION_FORM_DEFAULT_VALUES: Partial<NotificationWriteFormSchema> = {
+  recipientIds: [],
+  taskId: null,
+  payloadType: "NONE",
+}
 
 type NotificationWriteFormSchema = z.infer<typeof NotificationWriteSchema>
 
@@ -31,7 +33,6 @@ export const useNotificationWriteForm = ({
   label = "Legg inn ny varsling",
   defaultValues = NOTIFICATION_FORM_DEFAULT_VALUES,
 }: UseNotificationWriteFormProps) => {
-  
   const { groups } = useGroupAllQuery()
 
   return useFormBuilder({
@@ -40,6 +41,15 @@ export const useNotificationWriteForm = ({
     onSubmit,
     label,
     fields: {
+      recipientIds: createSearchableSelectInput({
+        multiSelect: true,
+        useSearchHook: useUserSearch,
+        dataMapper: (user) => ({ value: user.id, label: `${user.name} (${user.email})` }),
+        selectProps: {
+          label: "Mottakere",
+          placeholder: "Søk etter brukere",
+        },
+      }),
       title: createTextInput({
         label: "Tittel",
         placeholder: "Juleball Påmeldingen er åpen!",
@@ -50,34 +60,40 @@ export const useNotificationWriteForm = ({
         placeholder: "En kort beskrivelse av varslingen",
         required: true,
       }),
-       content: createRichTextInput({
+      content: createRichTextInput({
         label: "Innhold",
         required: true,
       }),
-        type: createSelectInput  ({
-        data: NOTIFICATION_FORM_DATA_TYPE,
+      type: createSelectInput({
+        data: Object.values(NotificationTypeSchema.Values).map((type) => ({
+          value: type,
+          label: mapNotificationTypeToLabel(type),
+        })),
         label: "Type",
         placeholder: "Velg type",
         required: true,
       }),
-        payload: createTextInput  ({
+      payloadType: createSelectInput({
+        label: "Payload Type",
+        data: Object.values(NotificationPayloadTypeSchema.Values).map((type) => ({
+          value: type,
+          label: mapNotificationPayloadTypeToLabel(type),
+        })),
+        placeholder: "Velg type",
+        required: true,
+      }),
+      payload: createTextInput({
         label: "Payload",
-        placeholder: "Paylaod",
+        placeholder: "Payload",
         required: false,
       }),
-        payloadType: createSelectInput  ({
-        label: "payload type",
-        data: NOTIFICATION_FORM_DATA_PAYLOAD_TYPE,
-        placeholder: "Velg type",
+      actorGroupId: createSelectInput({
+        label: "Ansvarlig gruppe",
+        placeholder: "Velg gruppe",
+        data: groups.map((group) => ({ value: group.slug, label: group.abbreviation })),
+        searchable: true,
         required: true,
       }),
-        actorGroupId: createSelectInput({
-         label: "Ansvarlig gruppe",
-         placeholder: "Velg gruppe",
-         data: groups.map((group) => ({ value: group.slug, label: group.abbreviation })),
-         searchable: true,
-         required: true,
-       }),     
     },
   })
-}
\ No newline at end of file
+}
diff --git a/apps/dashboard/src/components/forms/SearchableSelectInput.tsx b/apps/dashboard/src/components/forms/SearchableSelectInput.tsx
new file mode 100644
index 0000000000..b7d6d99859
--- /dev/null
+++ b/apps/dashboard/src/components/forms/SearchableSelectInput.tsx
@@ -0,0 +1,172 @@
+import { ErrorMessage } from "@hookform/error-message"
+import { Loader, MultiSelect, type MultiSelectProps, Select, type SelectProps } from "@mantine/core"
+import { useDebouncedValue } from "@mantine/hooks"
+import { useRef, useState } from "react"
+import { Controller, type FieldValues, useController } from "react-hook-form"
+import type { InputProducerResult } from "./types"
+
+export interface SelectOption {
+  value: string
+  label: string
+}
+
+interface UseSearchHookResult<T> {
+  data: T[]
+  isLoading: boolean
+}
+
+type UseSearchHook<T> = (searchQuery: string) => UseSearchHookResult<T>
+type DataMapper<T> = (item: T) => SelectOption
+type GetSelectedItem<T> = (id: string) => T | undefined
+
+interface BaseProps<T> {
+  /** Hook that performs the search query. Receives the debounced search string. */
+  useSearchHook: UseSearchHook<T>
+  /** Maps an item from the search results to a select option */
+  dataMapper: DataMapper<T>
+  /** Optional function to get a selected item by ID (for displaying selected items not in search results) */
+  getSelectedItem?: GetSelectedItem<T>
+  /** Debounce delay in milliseconds. Defaults to 300. */
+  debounceMs?: number
+}
+
+interface SingleSelectProps<T> extends BaseProps<T> {
+  multiSelect?: false
+  selectProps?: Omit<
+    SelectProps,
+    "data" | "value" | "onChange" | "error" | "searchable" | "searchValue" | "onSearchChange"
+  >
+}
+
+interface MultiSelectInputProps<T> extends BaseProps<T> {
+  multiSelect: true
+  selectProps?: Omit<
+    MultiSelectProps,
+    "data" | "value" | "onChange" | "error" | "searchable" | "searchValue" | "onSearchChange"
+  >
+}
+
+type Props<T> = SingleSelectProps<T> | MultiSelectInputProps<T>
+
+export function createSearchableSelectInput<F extends FieldValues, T>({
+  useSearchHook,
+  dataMapper,
+  getSelectedItem,
+  debounceMs = 300,
+  ...rest
+}: Props<T>): InputProducerResult<F> {
+  const isMultiSelect = "multiSelect" in rest && rest.multiSelect === true
+
+  return function FormSearchableSelectInput({ name, state, control }) {
+    const [searchQuery, setSearchQuery] = useState("")
+    const [debouncedSearchQuery] = useDebouncedValue(searchQuery, debounceMs)
+
+    // Cache to store selected items for display when they're not in search results
+    const selectedItemsCache = useRef<Map<string, T>>(new Map())
+
+    const { data, isLoading } = useSearchHook(debouncedSearchQuery)
+    const { field } = useController({ name, control })
+
+    const options = data.map(dataMapper)
+
+    // Cache items from current search results that match selected values
+    const selectedValues = isMultiSelect ? ((field.value as string[]) ?? []) : field.value ? [field.value] : []
+    for (const item of data) {
+      const mapped = dataMapper(item)
+      if (selectedValues.includes(mapped.value)) {
+        selectedItemsCache.current.set(mapped.value, item)
+      }
+    }
+
+    // Helper to find an item for a selected value
+    const findSelectedItem = (id: string): T | undefined => {
+      // Check cache first
+      const cachedItem = selectedItemsCache.current.get(id)
+      if (cachedItem) {
+        return cachedItem
+      }
+
+      // Try getSelectedItem if provided
+      if (getSelectedItem) {
+        const item = getSelectedItem(id)
+        if (item) {
+          selectedItemsCache.current.set(id, item)
+          return item
+        }
+      }
+
+      return undefined
+    }
+
+    // For single select: ensure selected value is in options
+    if (!isMultiSelect && field.value) {
+      if (!options.some((o) => o.value === field.value)) {
+        const selectedItem = findSelectedItem(field.value)
+        if (selectedItem) {
+          options.push(dataMapper(selectedItem))
+        }
+      }
+    }
+
+    // For multi select: ensure all selected values are in options
+    if (isMultiSelect && Array.isArray(field.value)) {
+      const selectedIds = field.value as string[]
+      for (const selectedId of selectedIds) {
+        if (!options.some((o) => o.value === selectedId)) {
+          const selectedItem = findSelectedItem(selectedId)
+          if (selectedItem) {
+            options.push(dataMapper(selectedItem))
+          }
+        }
+      }
+    }
+
+    const handleSearch = (query: string) => {
+      setSearchQuery(query)
+    }
+
+    if (isMultiSelect) {
+      const multiProps = (rest as MultiSelectInputProps<T>).selectProps
+      return (
+        <Controller
+          control={control}
+          name={name}
+          render={({ field }) => (
+            <MultiSelect
+              {...multiProps}
+              data={options}
+              value={field.value ?? []}
+              onChange={field.onChange}
+              searchValue={searchQuery}
+              onSearchChange={handleSearch}
+              searchable={true}
+              rightSection={isLoading ? <Loader size="xs" /> : undefined}
+              error={state.errors[name] && <ErrorMessage errors={state.errors} name={name} />}
+            />
+          )}
+        />
+      )
+    }
+
+    const singleProps = (rest as SingleSelectProps<T>).selectProps
+    return (
+      <Controller
+        control={control}
+        name={name}
+        render={({ field }) => (
+          <Select
+            {...singleProps}
+            data={options}
+            value={field.value}
+            onChange={field.onChange}
+            searchValue={searchQuery}
+            onSearchChange={handleSearch}
+            searchable={true}
+            rightSection={isLoading ? <Loader size="xs" /> : undefined}
+            error={state.errors[name] && <ErrorMessage errors={state.errors} name={name} />}
+          />
+        )}
+      />
+    )
+  }
+}
diff --git a/apps/dashboard/src/components/forms/hooks/useUserSearch.ts b/apps/dashboard/src/components/forms/hooks/useUserSearch.ts
new file mode 100644
index 0000000000..7262eaf6d3
--- /dev/null
+++ b/apps/dashboard/src/components/forms/hooks/useUserSearch.ts
@@ -0,0 +1,21 @@
+import { useUserAllQuery } from "@/app/(internal)/brukere/queries"
+
+/**
+ * Hook for searching users by name or email.
+ * Use with createSearchableSelectInput.
+ */
+export const useUserSearch = (searchQuery: string) => {
+  const { users, isLoading } = useUserAllQuery(
+    {
+      filter: {
+        byName: searchQuery,
+        byEmail: searchQuery,
+      },
+    },
+    {
+      enabled: searchQuery.length > 0, // Only fetch when there is a search query
+    }
+  )
+
+  return { data: users, isLoading }
+}
diff --git a/apps/rpc/src/index.ts b/apps/rpc/src/index.ts
index 8d92992e2a..a5ca2f379f 100644
--- a/apps/rpc/src/index.ts
+++ b/apps/rpc/src/index.ts
@@ -15,4 +15,5 @@ export type * as WorkspaceRouter from "./modules/workspace-sync/workspace-router
 export type * as UserRouter from "./modules/user/user-router"
 export type * as NotificationRouter from "./modules/notification/notification-router"
 
-
+export * from "./modules/notification/notification-types"
+export * from "./modules/notification/notification-utils"
diff --git a/apps/rpc/src/modules/notification/notification-repository.ts b/apps/rpc/src/modules/notification/notification-repository.ts
index 9cc3defc7f..23dfe3ffeb 100644
--- a/apps/rpc/src/modules/notification/notification-repository.ts
+++ b/apps/rpc/src/modules/notification/notification-repository.ts
@@ -1,39 +1,46 @@
 import type { DBHandle } from "@dotkomonline/db"
-import type {
-  Notification,
-  NotificationId,
-  NotificationWrite,
-  NotificationRecipientId,
-  NotificationRecipient,
-  UserNotification,
-} from "./notification"
-
+import {
+  type Notification,
+  type NotificationId,
+  type NotificationWrite,
+  type NotificationRecipientId,
+  type NotificationRecipient,
+  type UserNotification,
+  NotificationSchema,
+  NotificationRecipientSchema,
+  UserNotificationSchema,
+} from "./notification-types"
+import { parseOrReport } from "../../invariant"
 import type { UserId } from "@dotkomonline/types"
-import { Pageable, pageQuery } from "src/query"
+import { type Pageable, pageQuery } from "@dotkomonline/utils"
 
 export interface NotificationRepository {
   findById(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
-  findMany(handle: DBHandle, page: Pageable): Promise<Notification[]> 
-  create(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
+  findMany(handle: DBHandle, page: Pageable): Promise<Notification[]>
+  createWithRecipients(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
   update(
     handle: DBHandle,
     notificationId: NotificationId,
     notificationData: Partial<NotificationWrite>
   ): Promise<Notification>
-  delete(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+  delete(handle: DBHandle, notificationId: NotificationId): Promise<boolean>
 
-  addRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
-  removeRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
+  addRecipients(
+    handle: DBHandle,
+    notificationId: NotificationId,
+    recipientIds: UserId[]
+  ): Promise<NotificationRecipient[]>
+  removeRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<number>
 
   findRecipient(
     handle: DBHandle,
     recipientId: NotificationRecipientId,
     userId: UserId
   ): Promise<NotificationRecipient | null>
-  findAllForUser(handle: DBHandle, userId: UserId): Promise<UserNotification[]>
+  findAllForUser(handle: DBHandle, userId: UserId, page: Pageable): Promise<UserNotification[]>
   getUnreadCountForUser(handle: DBHandle, userId: UserId): Promise<number>
-  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<void>
-  markAllAsRead(handle: DBHandle, userId: UserId): Promise<void>
+  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<boolean>
+  markAllAsRead(handle: DBHandle, userId: UserId): Promise<boolean>
 }
 
 export function getNotificationRepository(): NotificationRepository {
@@ -41,41 +48,77 @@ export function getNotificationRepository(): NotificationRepository {
     async findById(handle, notificationId) {
       const notification = await handle.notification.findUnique({
         where: { id: notificationId },
+        include: {
+          actorGroup: {
+            include: {
+              roles: true,
+            },
+          },
+        },
       })
-      return notification
+      return parseOrReport(NotificationSchema, notification)
     },
 
-    async create(handle, notificationData) {
-      const { recipientIds, ...data } = notificationData
-      console.log("IDIOT", notificationData)
-      const notification = await handle.notification.create({ data })
-      return notification
+    async createWithRecipients(handle, data) {
+      const { recipientIds, ...notificationData } = data
+      const notification = await handle.notification.create({
+        data: {
+          ...notificationData,
+          recipients: {
+            createMany: {
+              data: recipientIds.map((userId) => ({
+                userId,
+              })),
+            },
+          },
+        },
+        include: {
+          actorGroup: {
+            include: {
+              roles: true,
+            },
+          },
+        },
+      })
+      return parseOrReport(NotificationSchema, notification)
     },
-    async update(handle, notificationId, notificationData) {
-      const { recipientIds, ...data } = notificationData
-      console.log("IDIOT", notificationData)
+
+    async update(handle, notificationId, data) {
       const notification = await handle.notification.update({
         where: { id: notificationId },
         data,
+        include: {
+          actorGroup: {
+            include: {
+              roles: true,
+            },
+          },
+        },
       })
-      return notification
+      return parseOrReport(NotificationSchema, notification)
     },
-   async findMany(handle, page) {
-      return await handle.notification.findMany({
+
+    async findMany(handle, page) {
+      const results = await handle.notification.findMany({
         ...pageQuery(page),
+        include: {
+          actorGroup: {
+            include: {
+              roles: true,
+            },
+          },
+        },
       })
+      return parseOrReport(NotificationSchema.array(), results)
     },
 
-
     async delete(handle, notificationId) {
-      const notification = await handle.notification.findUnique({
-        where: { id: notificationId },
-      })
-      await handle.notification.delete({
+      const deletedNotification = await handle.notification.delete({
         where: { id: notificationId },
       })
-      return notification
+      return !!deletedNotification
     },
+
     async findRecipient(handle, recipientId, userId) {
       const recipient = await handle.notificationRecipient.findFirst({
         where: {
@@ -83,30 +126,51 @@ export function getNotificationRepository(): NotificationRepository {
           userId,
         },
       })
-      return recipient
+      return parseOrReport(NotificationRecipientSchema, recipient)
     },
+
     async addRecipients(handle, notificationId, recipientIds) {
-      await handle.notificationRecipient.createMany({
+      const recipients = await handle.notificationRecipient.createMany({
         data: recipientIds.map((userId) => ({
           notificationId,
           userId,
         })),
       })
+      return parseOrReport(NotificationRecipientSchema.array(), recipients)
     },
+
     async removeRecipients(handle, notificationId, recipientIds) {
-      await handle.notificationRecipient.deleteMany({
+      const result = await handle.notificationRecipient.deleteMany({
         where: {
           notificationId,
           userId: { in: recipientIds },
         },
       })
+      return result.count
     },
 
-    async findAllForUser(handle, userId) {
-      return handle.notificationRecipient.findMany({
+    async findAllForUser(handle, userId, page) {
+      const userNotifications = await handle.notificationRecipient.findMany({
         where: { userId },
-        include: { notification: true },
+        ...pageQuery(page),
+        include: {
+          notification: {
+            include: {
+              actorGroup: {
+                include: {
+                  roles: true,
+                },
+              },
+            },
+          },
+        },
+        orderBy: {
+          notification: {
+            createdAt: "desc",
+          },
+        },
       })
+      return parseOrReport(UserNotificationSchema.array(), userNotifications)
     },
 
     async getUnreadCountForUser(handle, userId) {
@@ -114,18 +178,21 @@ export function getNotificationRepository(): NotificationRepository {
         where: { userId, readAt: null },
       })
     },
+
     async markAsRead(handle, notificationId, userId) {
-      await handle.notificationRecipient.updateMany({
+      const notificationRecipient = await handle.notificationRecipient.updateMany({
         where: { notificationId, userId, readAt: null },
         data: { readAt: new Date() },
       })
+      return notificationRecipient.count > 0
     },
 
     async markAllAsRead(handle, userId) {
-      await handle.notificationRecipient.updateMany({
+      const notificationRecipient = await handle.notificationRecipient.updateMany({
         where: { userId, readAt: null },
         data: { readAt: new Date() },
       })
+      return notificationRecipient.count > 0
     },
   }
 }
diff --git a/apps/rpc/src/modules/notification/notification-router.ts b/apps/rpc/src/modules/notification/notification-router.ts
index 5343da22ef..877bc90976 100644
--- a/apps/rpc/src/modules/notification/notification-router.ts
+++ b/apps/rpc/src/modules/notification/notification-router.ts
@@ -3,15 +3,22 @@ import { z } from "zod"
 import { isEditor } from "../../authorization"
 import { withAuditLogEntry, withAuthentication, withAuthorization, withDatabaseTransaction } from "../../middlewares"
 import { procedure, t } from "../../trpc"
-import { NotificationSchema, NotificationWriteSchema } from "./notification"
-import { BasePaginateInputSchema, PaginateInputSchema } from "src/query"
+import { BasePaginateInputSchema, PaginateInputSchema } from "@dotkomonline/utils"
+import {
+  NotificationDTOSchema,
+  NotificationSchema,
+  NotificationWriteSchema,
+  UserNotificationDTOSchema,
+  UserNotificationSchema,
+} from "./notification-types"
 
 export type GetNotificationInput = inferProcedureInput<typeof getNotificationProcedure>
 export type GetNotificationOutput = inferProcedureOutput<typeof getNotificationProcedure>
 const getNotificationProcedure = procedure
   .input(NotificationSchema.shape.id)
+  .output(NotificationDTOSchema.nullable())
   .use(withDatabaseTransaction())
-  .query(async ({ input, ctx }) => {
+  .query(({ input, ctx }) => {
     return ctx.notificationService.findById(ctx.handle, input)
   })
 
@@ -19,12 +26,13 @@ export type CreateNotificationInput = inferProcedureInput<typeof createNotificat
 export type CreateNotificationOutput = inferProcedureOutput<typeof createNotificationProcedure>
 const createNotificationProcedure = procedure
   .input(NotificationWriteSchema)
+  .output(NotificationDTOSchema)
   .use(withAuthentication())
   .use(withAuthorization(isEditor()))
   .use(withDatabaseTransaction())
   .use(withAuditLogEntry())
-  .mutation(async ({ input, ctx }) => {
-    return ctx.notificationService.create(ctx.handle, input)
+  .mutation(({ input, ctx }) => {
+    return ctx.notificationService.createWithRecipients(ctx.handle, input)
   })
 
 export type EditNotificationInput = inferProcedureInput<typeof editNotificationProcedure>
@@ -36,6 +44,7 @@ const editNotificationProcedure = procedure
       input: NotificationWriteSchema.partial(),
     })
   )
+  .output(NotificationDTOSchema)
   .use(withAuthentication())
   .use(withAuthorization(isEditor()))
   .use(withDatabaseTransaction())
@@ -48,6 +57,7 @@ export type DeleteNotificationInput = inferProcedureInput<typeof deleteNotificat
 export type DeleteNotificationOutput = inferProcedureOutput<typeof deleteNotificationProcedure>
 const deleteNotificationProcedure = procedure
   .input(NotificationSchema.shape.id)
+  .output(z.boolean())
   .use(withAuthentication())
   .use(withAuthorization(isEditor()))
   .use(withDatabaseTransaction())
@@ -59,15 +69,24 @@ const deleteNotificationProcedure = procedure
 export type GetMyNotificationsInput = inferProcedureInput<typeof getMyNotificationsProcedure>
 export type GetMyNotificationsOutput = inferProcedureOutput<typeof getMyNotificationsProcedure>
 const getMyNotificationsProcedure = procedure
+  .input(BasePaginateInputSchema)
+  .output(
+    z.object({ items: z.array(UserNotificationDTOSchema), nextCursor: UserNotificationSchema.shape.id.optional() })
+  )
   .use(withAuthentication())
   .use(withDatabaseTransaction())
-  .query(async ({ ctx }) => {
-    return ctx.notificationService.findAllForUser(ctx.handle, ctx.principal.subject)
+  .query(async ({ input, ctx }) => {
+    const notifications = await ctx.notificationService.findAllForUser(ctx.handle, ctx.principal.subject, input)
+    return {
+      items: notifications,
+      nextCursor: notifications.length === input.take ? notifications.at(-1)?.id : undefined,
+    }
   })
 
 export type GetUnreadCountInput = inferProcedureInput<typeof getUnreadCountProcedure>
 export type GetUnreadCountOutput = inferProcedureOutput<typeof getUnreadCountProcedure>
 const getUnreadCountProcedure = procedure
+  .output(z.number())
   .use(withAuthentication())
   .use(withDatabaseTransaction())
   .query(async ({ ctx }) => {
@@ -96,7 +115,10 @@ const markAllAsReadProcedure = procedure
 export type FindNotificationsInput = inferProcedureInput<typeof findNotificationsProcedure>
 export type FindNotificationsOutput = inferProcedureOutput<typeof findNotificationsProcedure>
 const findNotificationsProcedure = procedure
-  .input(PaginateInputSchema).use(withAuthentication()).use(withAuthorization(isEditor()))
+  .input(PaginateInputSchema)
+  .output(z.object({ items: z.array(NotificationDTOSchema), nextCursor: NotificationSchema.shape.id.optional() }))
+  .use(withAuthentication())
+  .use(withAuthorization(isEditor()))
   .use(withDatabaseTransaction())
   .query(async ({ input, ctx }) => {
     const items = await ctx.notificationService.findMany(ctx.handle, input)
diff --git a/apps/rpc/src/modules/notification/notification-service.ts b/apps/rpc/src/modules/notification/notification-service.ts
index 3a65d60bc5..8f70862a95 100644
--- a/apps/rpc/src/modules/notification/notification-service.ts
+++ b/apps/rpc/src/modules/notification/notification-service.ts
@@ -1,4 +1,8 @@
 import type { DBHandle } from "@dotkomonline/db"
+import type { UserId } from "@dotkomonline/types"
+import type { NotificationRepository } from "./notification-repository"
+import type { Pageable } from "@dotkomonline/utils"
+import type { UserRepository } from "../user/user-repository"
 import type {
   Notification,
   NotificationId,
@@ -6,22 +10,18 @@ import type {
   NotificationRecipientId,
   NotificationWrite,
   UserNotification,
-} from "./notification"
-import type { UserId } from "@dotkomonline/types"
-import type { NotificationRepository } from "./notification-repository"
-import { Pageable } from "src/query"
-import { UserRepository } from "../user/user-repository"
+} from "./notification-types"
 
 export interface NotificationService {
   findById(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
   findMany(handle: DBHandle, page: Pageable): Promise<Notification[]>
-  create(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
+  createWithRecipients(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
   update(
     handle: DBHandle,
     notificationId: NotificationId,
     notificationData: Partial<NotificationWrite>
   ): Promise<Notification>
-  delete(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+  delete(handle: DBHandle, notificationId: NotificationId): Promise<boolean>
 
   addRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
   removeRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
@@ -31,28 +31,32 @@ export interface NotificationService {
     recipientId: NotificationRecipientId,
     userId: UserId
   ): Promise<NotificationRecipient | null>
-  findAllForUser(handle: DBHandle, userId: UserId): Promise<UserNotification[]>
+  findAllForUser(handle: DBHandle, userId: UserId, page: Pageable): Promise<UserNotification[]>
   getUnreadCountForUser(handle: DBHandle, userId: UserId): Promise<number>
-  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<void>
-  markAllAsRead(handle: DBHandle, userId: UserId): Promise<void>
+  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<boolean>
+  markAllAsRead(handle: DBHandle, userId: UserId): Promise<boolean>
 }
 
-export function getNotificationService(notificationRepository: NotificationRepository, userRepository: UserRepository): NotificationService {
+export function getNotificationService(
+  notificationRepository: NotificationRepository,
+  userRepository: UserRepository
+): NotificationService {
   return {
     async findById(handle, notificationId) {
       return await notificationRepository.findById(handle, notificationId)
     },
-     async findMany(handle, page) {
+
+    async findMany(handle, page) {
       return await notificationRepository.findMany(handle, page)
     },
-    
-    async create(handle, notificationData) {
+
+    async createWithRecipients(handle, notificationData) {
       const data = { ...notificationData }
       if (data.recipientIds.length === 0) {
-        const users =  await userRepository.findMany(handle, {}, { take: 10000 })
-        data.recipientIds = users.map(user => user.id)
+        const users = await userRepository.findMany(handle, {}, { take: 10000 })
+        data.recipientIds = users.map((user) => user.id)
       }
-      return await notificationRepository.create(handle, data)
+      return await notificationRepository.createWithRecipients(handle, data)
     },
 
     async update(handle, notificationId, notificationData) {
@@ -75,8 +79,8 @@ export function getNotificationService(notificationRepository: NotificationRepos
       return await notificationRepository.findRecipient(handle, recipientId, userId)
     },
 
-    async findAllForUser(handle, userId) {
-      return await notificationRepository.findAllForUser(handle, userId)
+    async findAllForUser(handle, userId, page) {
+      return await notificationRepository.findAllForUser(handle, userId, page)
     },
 
     async getUnreadCountForUser(handle, userId) {
@@ -84,11 +88,11 @@ export function getNotificationService(notificationRepository: NotificationRepos
     },
 
     async markAsRead(handle, notificationId, userId) {
-      await notificationRepository.markAsRead(handle, notificationId, userId)
+      return await notificationRepository.markAsRead(handle, notificationId, userId)
     },
 
     async markAllAsRead(handle, userId) {
-      await notificationRepository.markAllAsRead(handle, userId)
+      return await notificationRepository.markAllAsRead(handle, userId)
     },
   }
 }
diff --git a/apps/rpc/src/modules/notification/notification-types.ts b/apps/rpc/src/modules/notification/notification-types.ts
new file mode 100644
index 0000000000..18ac76b845
--- /dev/null
+++ b/apps/rpc/src/modules/notification/notification-types.ts
@@ -0,0 +1,124 @@
+import { GroupSchema } from "@dotkomonline/types"
+import { z } from "zod"
+
+export const NotificationTypeSchema = z.enum([
+  "BROADCAST",
+  "BROADCAST_IMPORTANT",
+  "EVENT_REGISTRATION",
+  "EVENT_REMINDER",
+  "EVENT_UPDATE",
+  "JOB_LISTING_REMINDER",
+  "NEW_ARTICLE",
+  "NEW_EVENT",
+  "NEW_FEEDBACK_FORM",
+  "NEW_INTEREST_GROUP",
+  "NEW_JOB_LISTING",
+  "NEW_MARK",
+  "NEW_OFFLINE",
+])
+
+export type NotificationType = z.infer<typeof NotificationTypeSchema>
+
+export const NotificationPayloadTypeSchema = z.enum([
+  "NONE",
+  "URL",
+  "EVENT",
+  "ARTICLE",
+  "GROUP",
+  "USER",
+  "OFFLINE",
+  "JOB_LISTING",
+])
+
+export type NotificationPayloadType = z.infer<typeof NotificationPayloadTypeSchema>
+
+export const NotificationRecipientSchema = z.object({
+  id: z.string().uuid(),
+  readAt: z.coerce.date().nullable(),
+})
+
+export type NotificationRecipient = z.infer<typeof NotificationRecipientSchema>
+
+export const NotificationSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  title: z.string(),
+  shortDescription: z.string().nullable(),
+  content: z.string(),
+  type: NotificationTypeSchema,
+  payload: z.string().nullable(),
+  payloadType: NotificationPayloadTypeSchema,
+  actorGroupId: z.string(),
+  actorGroup: GroupSchema,
+  createdById: z.string().nullable(),
+  // createdBy: UserSchema.nullable(),
+  lastUpdatedById: z.string().nullable(),
+  // lastUpdatedBy: UserSchema.nullable(),
+  taskId: z.string().uuid().nullable(),
+  // task: TaskSchema.nullable(),
+  // recipients: z.array(NotificationRecipientSchema),
+})
+
+export type Notification = z.infer<typeof NotificationSchema>
+
+export const NotificationWriteSchema = NotificationSchema.pick({
+  title: true,
+  shortDescription: true,
+  content: true,
+  type: true,
+  payload: true,
+  payloadType: true,
+  actorGroupId: true,
+  taskId: true,
+}).extend({
+  recipientIds: z.array(z.string()),
+})
+
+export type NotificationWrite = z.infer<typeof NotificationWriteSchema>
+
+// ---- Additional Types ----
+
+export const UserNotificationSchema = z.object({
+  id: z.string().uuid(),
+  readAt: z.coerce.date().nullable(),
+  notification: NotificationSchema,
+})
+
+export type UserNotification = z.infer<typeof UserNotificationSchema>
+
+// ---- ID Types ----
+
+export type NotificationId = Notification["id"]
+
+export type NotificationRecipientId = NotificationRecipient["id"]
+
+// ---- DTOs ----
+
+export const NotificationDTOSchema = NotificationSchema.pick({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  title: true,
+  shortDescription: true,
+  content: true,
+  type: true,
+  payload: true,
+  payloadType: true,
+  actorGroupId: true,
+  createdById: true,
+  lastUpdatedById: true,
+  taskId: true,
+  actorGroup: true,
+})
+
+export type NotificationDTO = z.infer<typeof NotificationDTOSchema>
+
+export const UserNotificationDTOSchema = UserNotificationSchema.pick({
+  id: true,
+  readAt: true,
+}).extend({
+  notification: NotificationDTOSchema,
+})
+
+export type UserNotificationDTO = z.infer<typeof UserNotificationDTOSchema>
diff --git a/apps/rpc/src/modules/notification/notification-utils.ts b/apps/rpc/src/modules/notification/notification-utils.ts
new file mode 100644
index 0000000000..d1fedfb5a4
--- /dev/null
+++ b/apps/rpc/src/modules/notification/notification-utils.ts
@@ -0,0 +1,55 @@
+import type { NotificationPayloadType, NotificationType } from "./notification-types"
+
+export const mapNotificationTypeToLabel = (notificationType: NotificationType) => {
+  switch (notificationType) {
+    case "BROADCAST":
+      return "Generell varsling"
+    case "BROADCAST_IMPORTANT":
+      return "Viktig varsling"
+    case "EVENT_REGISTRATION":
+      return "Påmelding til arrangement"
+    case "EVENT_REMINDER":
+      return "Påminnelse om arrangement"
+    case "EVENT_UPDATE":
+      return "Oppdatering om arrangement"
+    case "JOB_LISTING_REMINDER":
+      return "Påminnelse om stillingsutlysning"
+    case "NEW_ARTICLE":
+      return "Ny artikkel"
+    case "NEW_EVENT":
+      return "Nytt arrangement"
+    case "NEW_FEEDBACK_FORM":
+      return "Nytt tilbakemeldingsskjema"
+    case "NEW_INTEREST_GROUP":
+      return "Ny interessegruppe"
+    case "NEW_JOB_LISTING":
+      return "Ny stillingsutlysning"
+    case "NEW_MARK":
+      return "Ny prikk"
+    case "NEW_OFFLINE":
+      return "Ny offline"
+    default:
+      return "Ukjent"
+  }
+}
+
+export const mapNotificationPayloadTypeToLabel = (payloadType: NotificationPayloadType) => {
+  switch (payloadType) {
+    case "URL":
+      return "Url"
+    case "EVENT":
+      return "Arrangement"
+    case "ARTICLE":
+      return "Artikkel"
+    case "GROUP":
+      return "Gruppe"
+    case "USER":
+      return "Bruker"
+    case "OFFLINE":
+      return "Offline"
+    case "JOB_LISTING":
+      return "Stillingsutlysning"
+    case "NONE":
+      return "Ingen"
+  }
+}
diff --git a/apps/rpc/src/modules/notification/notification.ts b/apps/rpc/src/modules/notification/notification.ts
deleted file mode 100644
index de3e7c3b93..0000000000
--- a/apps/rpc/src/modules/notification/notification.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { schemas } from "@dotkomonline/db/schemas"
-import { buildSearchFilter } from "@dotkomonline/types"
-import { z } from "zod"
-
-export type Notification = z.infer<typeof NotificationSchema>
-export const NotificationSchema = schemas.NotificationSchema
-export type NotificationId = Notification["id"]
-export type NotificationType = Notification["type"]
-export type NotificationPayloadType = Notification["payloadType"]
-
-export const NotificationTypeSchema = schemas.NotificationTypeSchema
-export const NotificationPayloadTypeSchema = schemas.NotificationPayloadTypeSchema
-
-export const NotificationRecipientSchema = schemas.NotificationRecipientSchema
-export type NotificationRecipient = z.infer<typeof NotificationRecipientSchema>
-
-export type NotificationRecipientId = NotificationRecipient["id"]
-
-export type UserNotification = z.infer<typeof UserNotificationSchema>
-export const UserNotificationSchema = schemas.NotificationRecipientSchema.extend({
-  notification: schemas.NotificationSchema,
-})
-
-export type NotificationWrite = z.infer<typeof NotificationWriteSchema>
-export const NotificationWriteSchema = NotificationSchema.pick({
-  title: true,
-  shortDescription: true,
-  content: true,
-  type: true,
-  payload: true,
-  payloadType: true,
-  actorGroupId: true,
-  taskId: true,
-}).extend({
-  recipientIds: z.array(z.string().uuid()),
-})
-
-
-
-export const mapNotificationTypeToLabel = (notificationType: NotificationType) => {
-  switch (notificationType) {
-    case "BROADCAST":
-      return "Generell varsling";
-    case "BROADCAST_IMPORTANT":
-      return "Viktig varsling";
-    case "EVENT_REGISTRATION":
-      return "Påmelding til arrangement";
-    case "EVENT_REMINDER":
-      return "Påminnelse om arrangement";
-    case "EVENT_UPDATE":
-      return "Oppdatering om arrangement";
-    case "JOB_LISTING_REMINDER":
-      return "Påminnelse om stillingsutlysning";
-    case "NEW_ARTICLE":
-      return "Ny artikkel";
-    case "NEW_EVENT":
-      return "Nytt arrangement";
-    case "NEW_FEEDBACK_FORM":
-      return "Nytt tilbakemeldingsskjema";
-    case "NEW_INTEREST_GROUP":
-      return "Ny interessegruppe";
-    case "NEW_JOB_LISTING":
-      return "Ny stillingsutlysning";
-    case "NEW_MARK":
-      return "Ny prikk";
-    case "NEW_OFFLINE":
-      return "Ny offline";
-    default:
-      return "Ukjent";
-  }
-}
-
-
-export const mapNotificationPayloadTypeToLabel = (payloadType: NotificationPayloadType) => {
-  switch (payloadType) {
-    case "URL":
-      return "Url";
-    case "EVENT":
-      return "Arrangement";
-    case "ARTICLE":
-      return "Artikkel";
-    case "GROUP":
-      return "Gruppe";
-    case "USER":
-      return "Bruker";
-    case "OFFLINE":
-      return "Offline";
-    case "JOB_LISTING":
-      return "Stillingsutlysning";
-    case "NONE":
-      return "Ingen";
-  }
-}
\ No newline at end of file
diff --git a/apps/web/src/components/Navbar/Notifications/NotificationDropdown.tsx b/apps/web/src/components/Navbar/Notifications/NotificationDropdown.tsx
index 1fb694e9e2..6feb01a656 100644
--- a/apps/web/src/components/Navbar/Notifications/NotificationDropdown.tsx
+++ b/apps/web/src/components/Navbar/Notifications/NotificationDropdown.tsx
@@ -1,31 +1,64 @@
 import { useEffect, useState, type ComponentProps } from "react"
 import * as DropdownMenu from "@radix-ui/react-dropdown-menu"
-import { NotificationItem, type NotificationItemType } from "./NotificationItem"
+import { NotificationItem } from "./NotificationItem"
 import { IconBell, IconLoader2 } from "@tabler/icons-react"
 import { cn } from "@dotkomonline/ui"
+import { useTRPC } from "@/utils/trpc/client"
+import { useInfiniteQuery, useMutation, useQueryClient } from "@tanstack/react-query"
+import type { UserNotificationDTO } from "@dotkomonline/rpc"
 
 interface NotificationDropdownProps extends ComponentProps<typeof DropdownMenu.Root> {
-  items?: NotificationItemType[]
-  hasMoreItems?: boolean
-  isLoading?: boolean
-  onReadMore?: () => void
+  open?: boolean
+  amountUnread?: number
 }
 
-export const NotificationDropdown = ({
-  items = [],
-  hasMoreItems = false,
-  isLoading,
-  onReadMore,
-  open,
-  ...props
-}: NotificationDropdownProps) => {
+export const NotificationDropdown = ({ open, amountUnread, ...props }: NotificationDropdownProps) => {
+  const trpc = useTRPC()
+  const queryClient = useQueryClient()
+
+  const { data, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading } = useInfiniteQuery({
+    ...trpc.notification.getMyNotifications.infiniteQueryOptions({ take: 10 }),
+    enabled: open,
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+  })
+
+  const markAllAsReadMutation = useMutation(
+    trpc.notification.markAllAsRead.mutationOptions({
+      onSuccess: async () => {
+        // Invalidate queries to refetch notifications and unread count
+        await Promise.all([
+          queryClient.invalidateQueries({
+            queryKey: trpc.notification.getMyNotifications.infiniteQueryOptions({ take: 10 }).queryKey,
+          }),
+          queryClient.invalidateQueries(trpc.notification.getUnreadCount.queryOptions()),
+        ])
+      },
+    })
+  )
+
+  const markAsReadMutation = useMutation(
+    trpc.notification.markAsRead.mutationOptions({
+      onSuccess: async () => {
+        // Invalidate queries to refetch notifications and unread count
+        await Promise.all([
+          queryClient.invalidateQueries({
+            queryKey: trpc.notification.getMyNotifications.infiniteQueryOptions({ take: 10 }).queryKey,
+          }),
+          queryClient.invalidateQueries(trpc.notification.getUnreadCount.queryOptions()),
+        ])
+      },
+    })
+  )
+
   const handleMarkAllAsRead = () => {
-    console.log("Mark all as read clicked")
+    markAllAsReadMutation.mutate()
   }
 
-  const handleItemClick = (item: NotificationItemType) => {
+  const handleItemClick = (item: UserNotificationDTO) => {
     // Use to set readAt. The redirection to the item should not happen in this callback.
-    console.log("Notification clicked:", item)
+    if (!item.readAt) {
+      markAsReadMutation.mutate({ notificationId: item.notification.id })
+    }
   }
 
   const [infiniteScrollEl, setInfiniteScrollEl] = useState<HTMLDivElement | null>(null)
@@ -37,37 +70,46 @@ export const NotificationDropdown = ({
       return
     }
     const observer = new IntersectionObserver((entries) => {
-      if (entries.some((e) => e.isIntersecting) && hasMoreItems) {
-        onReadMore?.()
+      if (entries.some((e) => e.isIntersecting) && hasNextPage && !isFetchingNextPage) {
+        fetchNextPage()
       }
     })
     observer.observe(infiniteScrollEl)
     return () => {
       observer.disconnect()
     }
-  }, [infiniteScrollEl, hasMoreItems, onReadMore])
+  }, [infiniteScrollEl, hasNextPage, isFetchingNextPage, fetchNextPage])
+
+  const notifications = data?.pages.flatMap((page) => page.items) ?? []
 
   return (
     <DropdownMenu.Root open={open} {...props}>
       <DropdownMenu.Trigger asChild>
         <button
           aria-label="Varslinger"
-          className="flex items-center justify-center w-10 h-10 rounded-full hover:bg-blue-200 dark:hover:bg-stone-700 transition-colors"
+          className="flex items-center justify-center w-10 h-10 rounded-full hover:bg-blue-200 dark:hover:bg-stone-700 transition-colors relative"
           type="button"
         >
           <IconBell width={24} height={24} />
+          {amountUnread !== undefined && amountUnread > 0 && (
+            <span className="absolute -top-1 -right-1 flex items-center justify-center min-w-5 h-5 px-1 text-white bg-red-500 rounded-full text-xs font-bold">
+              {amountUnread > 99 ? "99+" : amountUnread}
+            </span>
+          )}
         </button>
       </DropdownMenu.Trigger>
       <DropdownMenu.Portal>
         <DropdownMenu.Content
-          sideOffset={5}
+          align="end"
+          sideOffset={24}
           className={cn(
             "animate-in data-[side=right]:slide-in-from-left-2 data-[side=left]:slide-in-from-right-2",
             "data-[side=bottom]:slide-in-from-top-2 data-[side=top]:slide-in-from-bottom-2 z-50",
-            "w-102 overflow-hidden",
-            "rounded-lg shadow-lg",
-            "bg-white border border-black/10",
-            "dark:border-white/10 dark:bg-stone-800"
+            "w-[calc(100vw-2rem)] overflow-hidden",
+            "mx-4 xs:ml-4 xs:w-102 xs:-mr-16 lg:-mr-4",
+            "rounded-3xl shadow-sm",
+            "bg-blue-50 border border-blue-100",
+            "dark:border-white/10 dark:bg-stone-700"
           )}
         >
           <div className="p-5 border-b border-black/10 dark:border-white/10">
@@ -85,17 +127,19 @@ export const NotificationDropdown = ({
           </div>
 
           <div className="max-h-[min(32rem,50vh)] overflow-y-auto">
-            {items.length ? (
+            {notifications.length ? (
               <>
-                {items.map((item) => (
-                  <NotificationItem key={item.id} notification={item} onItemClick={() => handleItemClick(item)} />
+                {notifications.map((item) => (
+                  <NotificationItem key={item.id} userNotification={item} onItemClick={() => handleItemClick(item)} />
                 ))}
-                {hasMoreItems && <div ref={setInfiniteScrollEl} className="h-px -mt-px" />}
+                {hasNextPage && <div ref={setInfiniteScrollEl} className="h-px -mt-px" />}
               </>
             ) : (
               !isLoading && <p className="p-6 text-sm text-center text-black/60 dark:text-white/60">Ingen varslinger</p>
             )}
-            {isLoading && <IconLoader2 className="animate-spin size-4 mx-auto my-6 text-black/70 dark:text-white/70" />}
+            {(isLoading || isFetchingNextPage) && (
+              <IconLoader2 className="animate-spin size-4 mx-auto my-6 text-black/70 dark:text-white/70" />
+            )}
           </div>
         </DropdownMenu.Content>
       </DropdownMenu.Portal>
diff --git a/apps/web/src/components/Navbar/Notifications/NotificationItem.tsx b/apps/web/src/components/Navbar/Notifications/NotificationItem.tsx
index c5a5e1cdbc..68627fbbbf 100644
--- a/apps/web/src/components/Navbar/Notifications/NotificationItem.tsx
+++ b/apps/web/src/components/Navbar/Notifications/NotificationItem.tsx
@@ -14,23 +14,19 @@ import {
 import type { ComponentProps, ForwardRefExoticComponent, RefAttributes } from "react"
 import * as DropdownMenu from "@radix-ui/react-dropdown-menu"
 import { Badge, cn } from "@dotkomonline/ui"
-import type { NotificationPayloadType, NotificationType } from "@dotkomonline/types"
-
-export interface NotificationItemType {
-  id: string
-  createdAt: Date
-  updatedAt: Date
-  title: string
-  shortDescription: string
-  content: string
-  type: NotificationType
-  payload?: string
-  payloadType: NotificationPayloadType
-  actorGroupId: string
-  createdById?: string
-  lastUpdatedById?: string
-  taskId?: string
-  readAt?: Date
+import type { NotificationType, NotificationPayloadType, UserNotificationDTO } from "@dotkomonline/rpc"
+import { formatDistanceToNow, format, differenceInDays } from "date-fns"
+import { nb } from "date-fns/locale"
+import Link from "next/link"
+
+const formatNotificationTime = (date: Date): string => {
+  const now = new Date()
+  const daysDiff = differenceInDays(now, date)
+
+  if (daysDiff < 7) {
+    return formatDistanceToNow(date, { addSuffix: true, locale: nb })
+  }
+  return format(date, "d. MMM yyyy", { locale: nb })
 }
 
 export const NotificationIconMap: Record<
@@ -52,69 +48,114 @@ export const NotificationIconMap: Record<
   NEW_FEEDBACK_FORM: IconSpeakerphone,
 }
 
+const getNotificationUrl = (payloadType: NotificationPayloadType, payload: string | null): string | null => {
+  switch (payloadType) {
+    case "URL":
+      return payload
+    case "EVENT":
+      return payload ? `/arrangementer/${payload}` : null
+    case "ARTICLE":
+      return payload ? `/artikler/${payload}` : null
+    case "GROUP":
+      return payload ? `/grupper/${payload}` : null
+    case "USER":
+      return payload ? `/profil/${payload}` : null
+    case "OFFLINE":
+      return `/offline` // TODO: Fix in the future
+    case "JOB_LISTING":
+      return payload ? `/karriere/${payload}` : null
+    case "NONE":
+      return null
+  }
+}
+
 interface NotificationItem extends ComponentProps<typeof DropdownMenu.Item> {
-  notification: NotificationItemType
+  userNotification: UserNotificationDTO
   onItemClick?: () => void
 }
 
-export const NotificationItem = ({ notification, onItemClick, className, ...props }: NotificationItem) => {
+export const NotificationItem = ({ userNotification, onItemClick, className, ...props }: NotificationItem) => {
+  const notification = userNotification.notification
+
   const Icon = NotificationIconMap[notification.type]
-  const isRead = !!notification.readAt
+  const isRead = !!userNotification.readAt
   const isImportant = notification.type === "BROADCAST_IMPORTANT"
 
   const unreadItemColor = isImportant
-    ? "border-l-red-500 bg-red-500/5 hover:bg-red-500/10 focus-visible:bg-red-500/10 dark:focus-visible:bg-red-500/15"
-    : "border-l-blue-500 bg-blue-500/5 hover:bg-blue-500/10 focus-visible:bg-blue-500/10 dark:focus-visible:bg-blue-500/15"
+    ? "border-l-red-500 bg-red-500/10 hover:bg-red-500/10 focus-visible:bg-red-500/10 dark:focus-visible:bg-red-500/15"
+    : "border-l-blue-500 bg-blue-500/10 hover:bg-blue-500/10 focus-visible:bg-blue-500/10 dark:focus-visible:bg-blue-500/15"
   const unreadDotColor = isImportant ? "bg-red-500" : "bg-blue-500"
   const unreadTextColor = isImportant ? "text-red-600" : "text-blue-600"
   const unreadIconBgColor = isImportant ? "bg-red-500/20" : "bg-blue-500/20"
 
-  return (
-    <DropdownMenu.Item
-      {...props}
-      className={cn(
-        "flex gap-4 px-5 py-4 cursor-pointer border-l-4 focus-visible:outline-none not-last:border-b not-last:border-b-white/10",
-        { [unreadItemColor]: !isRead },
-        {
-          "opacity-80 border-transparent hover:bg-black/5 focus-visible:bg-black/10 dark:hover:bg-white/5 dark:focus-visible:bg-white/10":
-            isRead,
-        },
-        className
-      )}
-      onClick={onItemClick}
-    >
-      <div className="flex flex-row gap-3 w-full">
-        <div>
-          <div
-            className={cn(
-              "rounded-lg flex items-center justify-center h-10 w-10",
-              { [unreadIconBgColor]: !isRead },
-              { "bg-black/20": isRead }
-            )}
-          >
-            <Icon
-              className={cn("w-6 h-6", { [unreadTextColor]: !isRead }, { "text-stone-800 dark:text-white": isRead })}
-            />
-          </div>
-          {!isRead && <div className={cn("h-2 w-2 rounded-full mx-auto mt-2", unreadDotColor)} />}
-        </div>
-        <div className="flex flex-col p-0.5 w-full relative">
-          <p className="text-black/70 dark:text-white/70 text-xs ml-auto absolute top-0 right-0">5 timer siden</p>
-
-          {isImportant && (
-            <Badge
-              variant="solid"
-              color="red"
-              className={cn("bg-red-500 text-white text-xs py-1 px-2", { "mb-1": isImportant })}
-            >
-              Viktig melding
-            </Badge>
-          )}
+  const handleSelect = (event: Event) => {
+    if (notification.payloadType === "NONE") {
+      event.preventDefault()
+    }
+  }
 
-          <p className="font-semibold text-black dark:text-white text-sm">{notification.title}</p>
-          <p className="text-black dark:text-white/80 text-sm">{notification.shortDescription}</p>
+  const notificationUrl = getNotificationUrl(notification.payloadType, notification.payload)
+
+  const itemContent = (
+    <div className="flex flex-row gap-3 w-full">
+      <div>
+        <div
+          className={cn(
+            "rounded-lg flex items-center justify-center h-10 w-10",
+            { [unreadIconBgColor]: !isRead },
+            { "bg-black/10": isRead }
+          )}
+        >
+          <Icon
+            className={cn("w-6 h-6", { [unreadTextColor]: !isRead }, { "text-stone-800 dark:text-white": isRead })}
+          />
         </div>
+        {!isRead && <div className={cn("h-2 w-2 rounded-full mx-auto mt-2", unreadDotColor)} />}
       </div>
+      <div className="flex flex-col p-0.5 w-full relative">
+        <p className="text-black/70 dark:text-white/70 text-xs ml-auto absolute top-0 right-0">
+          {formatNotificationTime(new Date(notification.createdAt))}
+        </p>
+
+        {isImportant && (
+          <Badge
+            variant="solid"
+            color="red"
+            className={cn("bg-red-500 text-white text-xs py-1 px-2", { "mb-1": isImportant })}
+          >
+            Viktig melding
+          </Badge>
+        )}
+
+        <p className="font-semibold text-black dark:text-white text-sm">{notification.title}</p>
+        <p className="text-black dark:text-white/80 text-sm">{notification.shortDescription}</p>
+      </div>
+    </div>
+  )
+
+  const itemClassName = cn(
+    "flex gap-4 px-5 py-4 cursor-pointer border-l-4 focus-visible:outline-none not-last:border-b not-last:border-b-white/10",
+    { [unreadItemColor]: !isRead },
+    {
+      "opacity-80 border-transparent hover:bg-blue-100 focus-visible:bg-blue-100 dark:hover:bg-white/5 dark:focus-visible:bg-white/10":
+        isRead,
+    },
+    className
+  )
+
+  if (notificationUrl !== null) {
+    return (
+      <DropdownMenu.Item {...props} asChild onSelect={handleSelect} onClick={onItemClick}>
+        <Link href={notificationUrl} className={itemClassName}>
+          {itemContent}
+        </Link>
+      </DropdownMenu.Item>
+    )
+  }
+
+  return (
+    <DropdownMenu.Item {...props} className={itemClassName} onSelect={handleSelect} onClick={onItemClick}>
+      {itemContent}
     </DropdownMenu.Item>
   )
 }
diff --git a/apps/web/src/components/Navbar/ProfileMenu.tsx b/apps/web/src/components/Navbar/ProfileMenu.tsx
index defbd6504a..a9b48f1a7f 100644
--- a/apps/web/src/components/Navbar/ProfileMenu.tsx
+++ b/apps/web/src/components/Navbar/ProfileMenu.tsx
@@ -205,6 +205,8 @@ const linkGroups: LinkGroup[] = [
 
 export const ProfileMenu: FC = () => {
   const fullPathname = useFullPathname()
+  const trpc = useTRPC()
+
   const {
     sessionUser,
     isLoading,
@@ -216,6 +218,10 @@ export const ProfileMenu: FC = () => {
     dbUserQuery,
   } = useAuthenticatedUser()
 
+  const { data: amountUnread } = useQuery(
+    trpc.notification.getUnreadCount.queryOptions(undefined, { enabled: dbUser !== null })
+  )
+
   if (isLoading) {
     return null
   }
@@ -238,7 +244,7 @@ export const ProfileMenu: FC = () => {
   return (
     <div className="flex gap-1 mr-2 lg:mr-0">
       <ContactDebugDropdown />
-      <NotificationDropdown />
+      <NotificationDropdown amountUnread={amountUnread} />
       <AvatarDropdown dbUser={dbUser} dbUserIsLoading={dbUserQuery.isLoading} />
     </div>
   )
diff --git a/packages/db/prisma/migrations/20260325214642_fix_notification_recipient_table_name/migration.sql b/packages/db/prisma/migrations/20260325214642_fix_notification_recipient_table_name/migration.sql
new file mode 100644
index 0000000000..d33fd7c0e6
--- /dev/null
+++ b/packages/db/prisma/migrations/20260325214642_fix_notification_recipient_table_name/migration.sql
@@ -0,0 +1,30 @@
+/*
+  Warnings:
+
+  - You are about to drop the `NotificationRecipient` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "NotificationRecipient" DROP CONSTRAINT "NotificationRecipient_notification_id_fkey";
+
+-- DropForeignKey
+ALTER TABLE "NotificationRecipient" DROP CONSTRAINT "NotificationRecipient_user_id_fkey";
+
+-- DropTable
+DROP TABLE "NotificationRecipient";
+
+-- CreateTable
+CREATE TABLE "notification_recipient" (
+    "id" TEXT NOT NULL,
+    "read_at" TIMESTAMPTZ(3),
+    "notification_id" TEXT NOT NULL,
+    "user_id" TEXT NOT NULL,
+
+    CONSTRAINT "notification_recipient_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "notification_recipient" ADD CONSTRAINT "notification_recipient_notification_id_fkey" FOREIGN KEY ("notification_id") REFERENCES "notification"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notification_recipient" ADD CONSTRAINT "notification_recipient_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "ow_user"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 836efacde3..d703233ada 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -14,4 +14,3 @@ export * from "./task"
 export * from "./user"
 export * from "./audit-log"
 export * from "./workspace-sync"
-export * from "./notifications"
diff --git a/packages/types/src/notifications.ts b/packages/types/src/notifications.ts
deleted file mode 100644
index 7d6319424a..0000000000
--- a/packages/types/src/notifications.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { schemas } from "@dotkomonline/db/schemas"
-import type z from "zod"
-
-export const NotificationSchema = schemas.NotificationSchema.extend({})
-
-export type Notification = z.infer<typeof NotificationSchema>
-
-export const NotificationPayloadTypeSchema = schemas.NotificationPayloadTypeSchema
-
-export type NotificationPayloadType = z.infer<typeof NotificationPayloadTypeSchema>
-
-export const NotificationTypeSchema = schemas.NotificationTypeSchema
-
-export type NotificationType = z.infer<typeof NotificationTypeSchema>