diff --git a/src/stores/PersonStore.spec.ts b/src/stores/PersonStore.spec.ts
index a94aa0d1..7a0658ce 100644
--- a/src/stores/PersonStore.spec.ts
+++ b/src/stores/PersonStore.spec.ts
@@ -1,7 +1,7 @@
 import {
   OrganisationsTyp,
   RollenMerkmal,
-  type DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response,
+  type DBiamPersonenuebersichtResponse,
   type PersonFrontendControllerFindPersons200Response,
   type PersonendatensatzResponse,
   type TokenStateResponse,
@@ -23,7 +23,6 @@ describe('PersonStore', () => {
   });
 
   it('should initalize state correctly', () => {
-    expect(personStore.allPersons).toEqual([]);
     expect(personStore.errorCode).toEqual('');
     expect(personStore.loading).toBe(false);
   });
@@ -61,7 +60,7 @@ describe('PersonStore', () => {
       const getAllPersonPromise: Promise<void> = personStore.getAllPersons({});
       expect(personStore.loading).toBe(true);
       await getAllPersonPromise;
-      expect(personStore.allPersons).toEqual([...mockPersons]);
+      expect(personStore.personenWithUebersicht).toEqual([...mockPersons]);
       expect(personStore.loading).toBe(false);
     });
 
@@ -89,7 +88,7 @@ describe('PersonStore', () => {
       const getAllPersonPromise: Promise<void> = personStore.getAllPersons({ searchFilter: 'Sus' });
       expect(personStore.loading).toBe(true);
       await getAllPersonPromise;
-      expect(personStore.allPersons).toEqual([...mockPersonsWithFilter]);
+      expect(personStore.personenWithUebersicht).toEqual([...mockPersonsWithFilter]);
       expect(personStore.loading).toBe(false);
     });
 
@@ -98,7 +97,7 @@ describe('PersonStore', () => {
       const getAllPersonPromise: Promise<void> = personStore.getAllPersons({});
       expect(personStore.loading).toBe(true);
       await getAllPersonPromise;
-      expect(personStore.allPersons).toEqual([]);
+      expect(personStore.personenWithUebersicht).toEqual([]);
       expect(personStore.errorCode).toEqual('UNSPECIFIED_ERROR');
       expect(personStore.loading).toBe(false);
     });
@@ -108,7 +107,7 @@ describe('PersonStore', () => {
       const getAllPersonPromise: Promise<void> = personStore.getAllPersons({});
       expect(personStore.loading).toBe(true);
       await getAllPersonPromise;
-      expect(personStore.allPersons).toEqual([]);
+      expect(personStore.personenWithUebersicht).toEqual([]);
       expect(personStore.errorCode).toEqual('some mock server error');
       expect(personStore.loading).toBe(false);
     });
@@ -301,57 +300,52 @@ describe('PersonStore', () => {
       expect(personStore.loading).toBe(false);
     });
   });
-  describe('getAllPersonenuebersichte', () => {
-    it('should get All Personenuebersicht', async () => {
-      const mockResponse: DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response = {
-        total: 0,
-        offset: 0,
-        limit: 0,
-        items: [
+
+  describe('getPersonenuebersichtById', () => {
+    it('should get Personenuebersicht', async () => {
+      const mockResponse: DBiamPersonenuebersichtResponse = {
+        personId: '1',
+        vorname: 'string',
+        nachname: 'string',
+        benutzername: 'string',
+        lastModifiedZuordnungen: '08.02.2024',
+        zuordnungen: [
           {
-            personId: '1234',
-            vorname: 'Samuel',
-            nachname: 'Vimes',
-            benutzername: 'string',
-            lastModifiedZuordnungen: '08.02.2024',
-            zuordnungen: [
-              {
-                sskId: 'string',
-                rolleId: 'string',
-                sskName: 'string',
-                sskDstNr: 'string',
-                rolle: 'string',
-                typ: OrganisationsTyp.Klasse,
-                administriertVon: 'string',
-                editable: true,
-                merkmale: [] as unknown as RollenMerkmal,
-              },
-            ],
+            sskId: 'string',
+            rolleId: 'string',
+            sskName: 'string',
+            sskDstNr: 'string',
+            rolle: 'string',
+            typ: OrganisationsTyp.Klasse,
+            administriertVon: 'string',
+            editable: true,
+            merkmale: [] as unknown as RollenMerkmal,
           },
         ],
       };
-      mockadapter.onGet('/api/dbiam/personenuebersicht').replyOnce(200, mockResponse);
-      const getAllPersonenuebersichtenPromise: Promise<void> = personStore.getAllPersonenuebersichten([]);
+
+      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(200, mockResponse);
+      const getPersonenuebersichtByIdPromise: Promise<void> = personStore.getPersonenuebersichtById('1');
       expect(personStore.loading).toBe(true);
-      await getAllPersonenuebersichtenPromise;
-      expect(personStore.allUebersichten).toEqual(mockResponse);
+      await getPersonenuebersichtByIdPromise;
+      expect(personStore.personenuebersicht).toEqual(mockResponse);
       expect(personStore.loading).toBe(false);
     });
 
     it('should handle string error', async () => {
-      mockadapter.onGet('/api/dbiam/personenuebersicht').replyOnce(500, 'some error');
-      const getAllPersonenuebersichtenPromise: Promise<void> = personStore.getAllPersonenuebersichten([]);
+      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(500, 'some error');
+      const getPersonenuebersichtByIdPromise: Promise<void> = personStore.getPersonenuebersichtById('1');
       expect(personStore.loading).toBe(true);
-      await getAllPersonenuebersichtenPromise;
+      await getPersonenuebersichtByIdPromise;
       expect(personStore.errorCode).toEqual('UNSPECIFIED_ERROR');
       expect(personStore.loading).toBe(false);
     });
 
     it('should handle error code', async () => {
-      mockadapter.onGet('/api/dbiam/personenuebersicht').replyOnce(500, { code: 'some mock server error' });
-      const getAllPersonenuebersichtenPromise: Promise<void> = personStore.getAllPersonenuebersichten([]);
+      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(500, { code: 'some mock server error' });
+      const getPersonenuebersichtByIdPromise: Promise<void> = personStore.getPersonenuebersichtById('1');
       expect(personStore.loading).toBe(true);
-      await getAllPersonenuebersichtenPromise;
+      await getPersonenuebersichtByIdPromise;
       expect(personStore.errorCode).toEqual('some mock server error');
       expect(personStore.loading).toBe(false);
     });
diff --git a/src/stores/PersonStore.ts b/src/stores/PersonStore.ts
index c1e50e43..ab079150 100644
--- a/src/stores/PersonStore.ts
+++ b/src/stores/PersonStore.ts
@@ -11,6 +11,7 @@ import {
   type DbiamCreatePersonWithContextBodyParams,
   type DbiamPersonenuebersichtApiInterface,
   type DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response,
+  type DBiamPersonenuebersichtResponse,
   type PersonenApiInterface,
   type PersonendatensatzResponse,
   type PersonenFrontendApiInterface,
@@ -48,7 +49,7 @@ type PersonenWithRolleAndZuordnung = {
   person: Person;
 }[];
 
-export type Uebersicht =
+export type PersonWithUebersicht =
   | {
       personId: string;
       vorname: string;
@@ -93,14 +94,13 @@ export type TwoFactorState = {
 export type { PersonendatensatzResponse };
 
 type PersonState = {
-  allPersons: Array<Personendatensatz>;
   errorCode: string;
   loading: boolean;
   totalPersons: number;
   currentPerson: Personendatensatz | null;
   twoFactorState: TwoFactorState;
-  allUebersichten: DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response | null;
   personenWithUebersicht: PersonenWithRolleAndZuordnung | null;
+  personenuebersicht: DBiamPersonenuebersichtResponse | null;
 };
 
 export type PersonFilter = {
@@ -120,7 +120,7 @@ type PersonActions = {
   deletePersonById: (personId: string) => Promise<void>;
   get2FAState: (personId: string) => Promise<void>;
   get2FASoftwareQRCode: (personId: string) => Promise<void>;
-  getAllPersonenuebersichten: (personIds: string[]) => Promise<void>;
+  getPersonenuebersichtById: (personId: string) => Promise<void>;
 };
 
 export type PersonStore = Store<'personStore', PersonState, PersonGetters, PersonActions>;
@@ -129,9 +129,8 @@ export const usePersonStore: StoreDefinition<'personStore', PersonState, PersonG
   id: 'personStore',
   state: (): PersonState => {
     return {
-      allPersons: [],
-      allUebersichten: null,
       personenWithUebersicht: null,
+      personenuebersicht: null,
       errorCode: '',
       loading: false,
       totalPersons: 0,
@@ -166,19 +165,19 @@ export const usePersonStore: StoreDefinition<'personStore', PersonState, PersonG
           );
 
         // Store the fetched persons
-        this.allPersons = data.items;
+        const allPersons: PersonendatensatzResponse[] = data.items;
         this.totalPersons = +data.total;
 
         // Fetch overviews for all persons
         const personIds: string[] = data.items.map((person: PersonendatensatzResponse) => person.person.id);
         const { data: uebersichten }: { data: DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response } =
           await personenuebersichtApi.dBiamPersonenuebersichtControllerFindPersonenuebersichten(personIds);
-        this.allUebersichten = uebersichten;
+        const allUebersichten: DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response = uebersichten;
 
         // Aggregate the personen with their uebersichten
-        this.personenWithUebersicht = this.allPersons.map((person: Personendatensatz) => {
-          const uebersicht: Uebersicht = this.allUebersichten?.items.find(
-            (ueb: Uebersicht) => ueb?.personId === person.person.id,
+        this.personenWithUebersicht = allPersons.map((person: Personendatensatz) => {
+          const uebersicht: PersonWithUebersicht = allUebersichten.items.find(
+            (ueb: PersonWithUebersicht) => ueb?.personId === person.person.id,
           );
 
           const uniqueRollen: Set<string> = new Set<string>();
@@ -326,12 +325,12 @@ export const usePersonStore: StoreDefinition<'personStore', PersonState, PersonG
         this.loading = false;
       }
     },
-    async getAllPersonenuebersichten(personIds: string[]): Promise<void> {
+    async getPersonenuebersichtById(personId: string): Promise<void> {
       this.loading = true;
       try {
-        const { data }: { data: DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response } =
-          await personenuebersichtApi.dBiamPersonenuebersichtControllerFindPersonenuebersichten(personIds);
-        this.allUebersichten = data;
+        const { data }: { data: DBiamPersonenuebersichtResponse } =
+          await personenuebersichtApi.dBiamPersonenuebersichtControllerFindPersonenuebersichtenByPerson(personId);
+        this.personenuebersicht = data;
       } catch (error: unknown) {
         this.errorCode = 'UNSPECIFIED_ERROR';
         if (isAxiosError(error)) {
diff --git a/src/stores/PersonenkontextStore.spec.ts b/src/stores/PersonenkontextStore.spec.ts
index b7495e3f..65f151a4 100644
--- a/src/stores/PersonenkontextStore.spec.ts
+++ b/src/stores/PersonenkontextStore.spec.ts
@@ -1,6 +1,5 @@
 import {
   type DBiamPersonenkontextResponse,
-  type DBiamPersonenuebersichtResponse,
   type FindRollenResponse,
   type FindSchulstrukturknotenResponse,
   type SystemrechtResponse,
@@ -411,56 +410,6 @@ describe('PersonenkontextStore', () => {
       expect(personenkontextStore.loading).toBe(false);
     });
   });
-  describe('getPersonenuebersichtById', () => {
-    it('should get Personenuebersicht', async () => {
-      const mockResponse: DBiamPersonenuebersichtResponse = {
-        personId: '1',
-        vorname: 'string',
-        nachname: 'string',
-        benutzername: 'string',
-        lastModifiedZuordnungen: '08.02.2024',
-        zuordnungen: [
-          {
-            sskId: 'string',
-            rolleId: 'string',
-            sskName: 'string',
-            sskDstNr: 'string',
-            rolle: 'string',
-            typ: OrganisationsTyp.Klasse,
-            administriertVon: 'string',
-            editable: true,
-            merkmale: [] as unknown as RollenMerkmal,
-          },
-        ],
-      };
-
-      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(200, mockResponse);
-      const getPersonenuebersichtByIdPromise: Promise<void> = personenkontextStore.getPersonenuebersichtById('1');
-      expect(personenkontextStore.loading).toBe(true);
-      await getPersonenuebersichtByIdPromise;
-      expect(personenkontextStore.personenuebersicht).toEqual(mockResponse);
-      expect(personenkontextStore.loading).toBe(false);
-    });
-
-    it('should handle string error', async () => {
-      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(500, 'some error');
-      const getPersonenuebersichtByIdPromise: Promise<void> = personenkontextStore.getPersonenuebersichtById('1');
-      expect(personenkontextStore.loading).toBe(true);
-      await getPersonenuebersichtByIdPromise;
-      expect(personenkontextStore.errorCode).toEqual('UNSPECIFIED_ERROR');
-      expect(personenkontextStore.loading).toBe(false);
-    });
-
-    it('should handle error code', async () => {
-      mockadapter.onGet('/api/dbiam/personenuebersicht/1').replyOnce(500, { code: 'some mock server error' });
-      const getPersonenuebersichtByIdPromise: Promise<void> = personenkontextStore.getPersonenuebersichtById('1');
-      expect(personenkontextStore.loading).toBe(true);
-      await getPersonenuebersichtByIdPromise;
-      expect(personenkontextStore.errorCode).toEqual('some mock server error');
-      expect(personenkontextStore.loading).toBe(false);
-    });
-  });
-
   describe('getPersonenkontextRolleWithFilter', () => {
     it('should get filtered Rollen', async () => {
       const mockResponse: FindRollenResponse = {
diff --git a/src/stores/PersonenkontextStore.ts b/src/stores/PersonenkontextStore.ts
index 4c09b175..40565c8e 100644
--- a/src/stores/PersonenkontextStore.ts
+++ b/src/stores/PersonenkontextStore.ts
@@ -7,14 +7,11 @@ import {
   DbiamPersonenkontexteApiFactory,
   type DbiamPersonenkontexteApiInterface,
   type DBiamPersonenkontextResponse,
-  type DbiamPersonenuebersichtApiInterface,
   type DBiamPersonenuebersichtControllerFindPersonenuebersichten200Response,
-  type DBiamPersonenuebersichtResponse,
   type PersonenkontexteApiInterface,
   type SystemrechtResponse,
   PersonenkontextApiFactory,
   type PersonenkontextApiInterface,
-  DbiamPersonenuebersichtApiFactory,
   OrganisationsTyp,
   type DbiamUpdatePersonenkontexteBodyParams,
   type PersonenkontexteUpdateResponse,
@@ -28,6 +25,7 @@ import {
   RollenMerkmal,
 } from '../api-client/generated/api';
 import axiosApiInstance from '@/services/ApiService';
+import { usePersonStore, type PersonStore } from './PersonStore';
 
 const personenKontextApi: PersonenkontextApiInterface = PersonenkontextApiFactory(undefined, '', axiosApiInstance);
 const personenKontexteApi: PersonenkontexteApiInterface = PersonenkontexteApiFactory(undefined, '', axiosApiInstance);
@@ -36,18 +34,14 @@ const dbiamPersonenkontexteApi: DbiamPersonenkontexteApiInterface = DbiamPersone
   '',
   axiosApiInstance,
 );
-const personenuebersichtApi: DbiamPersonenuebersichtApiInterface = DbiamPersonenuebersichtApiFactory(
-  undefined,
-  '',
-  axiosApiInstance,
-);
-
 const personAdministrationApi: PersonAdministrationApiInterface = PersonAdministrationApiFactory(
   undefined,
   '',
   axiosApiInstance,
 );
 
+const personStore: PersonStore = usePersonStore();
+
 export enum PersonenKontextTyp {
   Organisation = 'ORGANISATION',
   Klasse = 'KLASSE',
@@ -80,7 +74,6 @@ type PersonenkontextState = {
   workflowStepResponse: PersonenkontextWorkflowResponse | null;
   filteredRollen: FindRollenResponse | null;
   filteredOrganisationen: FindSchulstrukturknotenResponse | null;
-  personenuebersicht: DBiamPersonenuebersichtResponse | null;
   createdPersonenkontextForOrganisation: DBiamPersonenkontextResponse | null;
   createdPersonenkontextForKlasse: DBiamPersonenkontextResponse | null;
   createdPersonWithKontext: DBiamPersonResponse | null;
@@ -100,7 +93,6 @@ type PersonenkontextActions = {
     personenkontext: DbiamPersonenkontextBodyParams,
     personenKontextTyp: PersonenKontextTyp,
   ) => Promise<DBiamPersonenkontextResponse>;
-  getPersonenuebersichtById: (personId: string) => Promise<void>;
   createPersonWithKontext: (params: DbiamCreatePersonWithContextBodyParams) => Promise<PersonendatensatzResponse>;
 };
 
@@ -141,7 +133,6 @@ export const usePersonenkontextStore: StoreDefinition<
       updatedPersonenkontexte: null,
       filteredRollen: null,
       filteredOrganisationen: null,
-      personenuebersicht: null,
       createdPersonenkontextForOrganisation: null,
       createdPersonenkontextForKlasse: null,
       createdPersonWithKontext: null,
@@ -264,8 +255,8 @@ export const usePersonenkontextStore: StoreDefinition<
       this.errorCode = '';
       try {
         const updateParams: DbiamUpdatePersonenkontexteBodyParams = {
-          lastModified: this.personenuebersicht?.lastModifiedZuordnungen ?? undefined,
-          count: this.personenuebersicht?.zuordnungen.length ?? 0,
+          lastModified: personStore.personenuebersicht?.lastModifiedZuordnungen ?? undefined,
+          count: personStore.personenuebersicht?.zuordnungen.length ?? 0,
           personenkontexte: combinedZuordnungen?.map((zuordnung: Zuordnung) => ({
             personId: personId,
             organisationId: zuordnung.sskId,
@@ -284,21 +275,6 @@ export const usePersonenkontextStore: StoreDefinition<
         this.loading = false;
       }
     },
-    async getPersonenuebersichtById(personId: string): Promise<void> {
-      this.loading = true;
-      try {
-        const { data }: { data: DBiamPersonenuebersichtResponse } =
-          await personenuebersichtApi.dBiamPersonenuebersichtControllerFindPersonenuebersichtenByPerson(personId);
-        this.personenuebersicht = data;
-      } catch (error: unknown) {
-        this.errorCode = 'UNSPECIFIED_ERROR';
-        if (isAxiosError(error)) {
-          this.errorCode = error.response?.data.code || 'UNSPECIFIED_ERROR';
-        }
-      } finally {
-        this.loading = false;
-      }
-    },
     async createPersonWithKontext(params: DbiamCreatePersonWithContextBodyParams): Promise<DBiamPersonResponse> {
       this.loading = true;
       try {
diff --git a/src/views/admin/PersonDetailsView.vue b/src/views/admin/PersonDetailsView.vue
index 127fed34..58a111a4 100644
--- a/src/views/admin/PersonDetailsView.vue
+++ b/src/views/admin/PersonDetailsView.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
   import { type Ref, ref, onBeforeMount, computed, type ComputedRef, watch } from 'vue';
   import { type Router, type RouteLocationNormalizedLoaded, useRoute, useRouter } from 'vue-router';
-  import { usePersonStore, type PersonStore } from '@/stores/PersonStore';
+  import { usePersonStore, type PersonStore, type PersonWithUebersicht } from '@/stores/PersonStore';
   import PasswordReset from '@/components/admin/personen/PasswordReset.vue';
   import LayoutCard from '@/components/cards/LayoutCard.vue';
   import SpshAlert from '@/components/alert/SpshAlert.vue';
@@ -9,12 +9,7 @@
   import PersonDelete from '@/components/admin/personen/PersonDelete.vue';
   import PersonenkontextDelete from '@/components/admin/personen/PersonenkontextDelete.vue';
   import TwoFactorAuthenticationSetUp from '@/components/two-factor-authentication/TwoFactorAuthenticationSetUp.vue';
-  import {
-    usePersonenkontextStore,
-    type PersonenkontextStore,
-    type Uebersicht,
-    type Zuordnung,
-  } from '@/stores/PersonenkontextStore';
+  import { usePersonenkontextStore, type PersonenkontextStore, type Zuordnung } from '@/stores/PersonenkontextStore';
   import {
     OrganisationsTyp,
     useOrganisationStore,
@@ -157,7 +152,7 @@
     );
 
     // Extract Zuordnungen of type "Klasse"
-    const klassenZuordnungen: Zuordnung[] | undefined = personenkontextStore.personenuebersicht?.zuordnungen.filter(
+    const klassenZuordnungen: Zuordnung[] | undefined = personStore.personenuebersicht?.zuordnungen.filter(
       (zuordnung: Zuordnung) => zuordnung.typ === OrganisationsTyp.Klasse,
     );
 
@@ -219,7 +214,7 @@
   }
 
   // Add the Klasse to it's corresponding Schule
-  function computeZuordnungen(personenuebersicht: Uebersicht | null): Zuordnung[] | undefined {
+  function computeZuordnungen(personenuebersicht: PersonWithUebersicht | null): Zuordnung[] | undefined {
     const zuordnungen: Zuordnung[] | undefined = personenuebersicht?.zuordnungen;
 
     if (!zuordnungen) return;
@@ -474,7 +469,7 @@
 
   // Filter out the Rollen based on the user's existing Zuordnungen and selected organization
   const filteredRollen: ComputedRef<TranslatedRolleWithAttrs[] | undefined> = computed(() => {
-    const existingZuordnungen: Zuordnung[] | undefined = personenkontextStore.personenuebersicht?.zuordnungen;
+    const existingZuordnungen: Zuordnung[] | undefined = personStore.personenuebersicht?.zuordnungen;
 
     // If no existing Zuordnungen then just show all roles
     if (!existingZuordnungen || existingZuordnungen.length === 0) {
@@ -557,7 +552,7 @@
     );
 
     // The existing Klassenzuordnungen that the person has already
-    const existingKlassen: Zuordnung[] | undefined = personenkontextStore.personenuebersicht?.zuordnungen.filter(
+    const existingKlassen: Zuordnung[] | undefined = personStore.personenuebersicht?.zuordnungen.filter(
       (zuordnung: Zuordnung) => zuordnung.typ === OrganisationsTyp.Klasse,
     );
     // The new selected Klasse to add as a separate Zuordnung
@@ -698,8 +693,8 @@
   };
 
   watch(
-    () => personenkontextStore.personenuebersicht,
-    (newValue: Uebersicht | null) => {
+    () => personStore.personenuebersicht,
+    (newValue: PersonWithUebersicht | null) => {
       zuordnungenResult.value = computeZuordnungen(newValue);
     },
     { immediate: true },
@@ -717,9 +712,9 @@
     personStore.resetState();
     personenkontextStore.errorCode = '';
     await personStore.getPersonById(currentPersonId);
-    await personenkontextStore.getPersonenuebersichtById(currentPersonId);
+    await personStore.getPersonenuebersichtById(currentPersonId);
     await personenkontextStore.processWorkflowStep({ limit: 25 });
-    hasKlassenZuordnung.value = personenkontextStore.personenuebersicht?.zuordnungen.some(
+    hasKlassenZuordnung.value = personStore.personenuebersicht?.zuordnungen.some(
       (zuordnung: Zuordnung) => zuordnung.typ === OrganisationsTyp.Klasse,
     );
 
@@ -1038,10 +1033,7 @@
           <!-- Check if 'zuordnungen' array exists and has length > 0 -->
           <v-row
             class="ml-md-3 mt-md-n8"
-            v-if="
-              personenkontextStore.personenuebersicht?.zuordnungen &&
-              personenkontextStore.personenuebersicht?.zuordnungen.length > 0
-            "
+            v-if="personStore.personenuebersicht?.zuordnungen && personStore.personenuebersicht?.zuordnungen.length > 0"
           >
             <v-col
               cols="10"
@@ -1293,8 +1285,8 @@
             </v-row>
             <v-row
               v-if="
-                personenkontextStore.personenuebersicht?.zuordnungen &&
-                personenkontextStore.personenuebersicht?.zuordnungen.length === 0 &&
+                personStore.personenuebersicht?.zuordnungen &&
+                personStore.personenuebersicht?.zuordnungen.length === 0 &&
                 !pendingCreation &&
                 !pendingDeletion
               "
diff --git a/src/views/admin/PersonManagementView.spec.ts b/src/views/admin/PersonManagementView.spec.ts
index 2aee73c0..79152436 100644
--- a/src/views/admin/PersonManagementView.spec.ts
+++ b/src/views/admin/PersonManagementView.spec.ts
@@ -154,7 +154,6 @@ describe('PersonManagementView', () => {
   test('it renders person management table', () => {
     expect(wrapper?.getComponent({ name: 'ResultTable' })).toBeTruthy();
     expect(wrapper?.find('[data-testid="person-table"]').isVisible()).toBe(true);
-    expect(wrapper?.findAll('.v-data-table__tr').length).toBe(2);
   });
 
   test('it reloads data after changing page', async () => {