diff --git a/apps/server/src/modules/group/domain/interface/group-filter.ts b/apps/server/src/modules/group/domain/interface/group-filter.ts
index 7baaffbf511..228cf147e28 100644
--- a/apps/server/src/modules/group/domain/interface/group-filter.ts
+++ b/apps/server/src/modules/group/domain/interface/group-filter.ts
@@ -3,6 +3,7 @@ import { EntityId } from '@shared/domain/types';
 
 export interface GroupFilter {
 	userId?: EntityId;
+	userIds?: EntityId[];
 	schoolId?: EntityId;
 	systemId?: EntityId;
 	groupTypes?: GroupTypes[];
diff --git a/apps/server/src/modules/group/repo/group.repo.ts b/apps/server/src/modules/group/repo/group.repo.ts
index 180bc4fd6ae..af58c1d4f18 100644
--- a/apps/server/src/modules/group/repo/group.repo.ts
+++ b/apps/server/src/modules/group/repo/group.repo.ts
@@ -57,6 +57,7 @@ export class GroupRepo extends BaseDomainObjectRepo<Group, GroupEntity> {
 	public async findGroups(filter: GroupFilter, options?: IFindOptions<Group>): Promise<Page<Group>> {
 		const scope: GroupScope = new GroupScope();
 		scope.byUserId(filter.userId);
+		scope.byUserIds(filter.userIds);
 		scope.byOrganizationId(filter.schoolId);
 		scope.bySystemId(filter.systemId);
 
diff --git a/apps/server/src/modules/group/repo/group.scope.ts b/apps/server/src/modules/group/repo/group.scope.ts
index e227f111408..5b879c92609 100644
--- a/apps/server/src/modules/group/repo/group.scope.ts
+++ b/apps/server/src/modules/group/repo/group.scope.ts
@@ -5,35 +5,42 @@ import { Scope } from '@shared/repo/scope';
 import { GroupEntity, GroupEntityTypes } from '../entity';
 
 export class GroupScope extends Scope<GroupEntity> {
-	byTypes(types: GroupEntityTypes[] | undefined): this {
+	public byTypes(types: GroupEntityTypes[] | undefined): this {
 		if (types) {
 			this.addQuery({ type: { $in: types } });
 		}
 		return this;
 	}
 
-	byOrganizationId(id: EntityId | undefined): this {
+	public byOrganizationId(id: EntityId | undefined): this {
 		if (id) {
 			this.addQuery({ organization: id });
 		}
 		return this;
 	}
 
-	bySystemId(id: EntityId | undefined): this {
+	public bySystemId(id: EntityId | undefined): this {
 		if (id) {
 			this.addQuery({ externalSource: { system: new ObjectId(id) } });
 		}
 		return this;
 	}
 
-	byUserId(id: EntityId | undefined): this {
+	public byUserId(id: EntityId | undefined): this {
 		if (id) {
 			this.addQuery({ users: { user: new ObjectId(id) } });
 		}
 		return this;
 	}
 
-	byNameQuery(nameQuery: string | undefined): this {
+	public byUserIds(ids: EntityId[] | undefined): this {
+		if (ids) {
+			this.addQuery({ users: { user: { $in: ids.map((id) => new ObjectId(id)) } } });
+		}
+		return this;
+	}
+
+	public byNameQuery(nameQuery: string | undefined): this {
 		if (nameQuery) {
 			const escapedName = nameQuery.replace(MongoPatterns.REGEX_MONGO_LANGUAGE_PATTERN_WHITELIST, '').trim();
 			this.addQuery({ name: new RegExp(escapedName, 'i') });
diff --git a/apps/server/src/modules/room-membership/repo/room-membership.repo.ts b/apps/server/src/modules/room-membership/repo/room-membership.repo.ts
index 5db8b3750ce..5477302b252 100644
--- a/apps/server/src/modules/room-membership/repo/room-membership.repo.ts
+++ b/apps/server/src/modules/room-membership/repo/room-membership.repo.ts
@@ -10,7 +10,7 @@ import { RoomMembershipDomainMapper } from './room-membership-domain.mapper';
 export class RoomMembershipRepo {
 	constructor(private readonly em: EntityManager) {}
 
-	async findByRoomId(roomId: EntityId): Promise<RoomMembership | null> {
+	public async findByRoomId(roomId: EntityId): Promise<RoomMembership | null> {
 		const roomMembershipEntities = await this.em.findOne(RoomMembershipEntity, { roomId });
 		if (!roomMembershipEntities) return null;
 
@@ -19,28 +19,28 @@ export class RoomMembershipRepo {
 		return roomMemberships;
 	}
 
-	async findByRoomIds(roomIds: EntityId[]): Promise<RoomMembership[]> {
+	public async findByRoomIds(roomIds: EntityId[]): Promise<RoomMembership[]> {
 		const entities = await this.em.find(RoomMembershipEntity, { roomId: { $in: roomIds } });
 		const roomMemberships = entities.map((entity) => RoomMembershipDomainMapper.mapEntityToDo(entity));
 
 		return roomMemberships;
 	}
 
-	async findByGroupId(groupId: EntityId): Promise<RoomMembership[]> {
+	public async findByGroupId(groupId: EntityId): Promise<RoomMembership[]> {
 		const entities = await this.em.find(RoomMembershipEntity, { userGroupId: groupId });
 		const roomMemberships = entities.map((entity) => RoomMembershipDomainMapper.mapEntityToDo(entity));
 
 		return roomMemberships;
 	}
 
-	async findByGroupIds(groupIds: EntityId[]): Promise<RoomMembership[]> {
+	public async findByGroupIds(groupIds: EntityId[]): Promise<RoomMembership[]> {
 		const entities = await this.em.find(RoomMembershipEntity, { userGroupId: { $in: groupIds } });
 		const roomMemberships = entities.map((entity) => RoomMembershipDomainMapper.mapEntityToDo(entity));
 
 		return roomMemberships;
 	}
 
-	async save(roomMembership: RoomMembership | RoomMembership[]): Promise<void> {
+	public async save(roomMembership: RoomMembership | RoomMembership[]): Promise<void> {
 		const roomMemberships = Utils.asArray(roomMembership);
 
 		roomMemberships.forEach((member) => {
@@ -51,7 +51,7 @@ export class RoomMembershipRepo {
 		await this.em.flush();
 	}
 
-	async delete(roomMembership: RoomMembership | RoomMembership[]): Promise<void> {
+	public async delete(roomMembership: RoomMembership | RoomMembership[]): Promise<void> {
 		const roomMemberships = Utils.asArray(roomMembership);
 
 		roomMemberships.forEach((member) => {
diff --git a/apps/server/src/modules/room-membership/room-membership.module.ts b/apps/server/src/modules/room-membership/room-membership.module.ts
index a261d8ea475..1015fd7b9a8 100644
--- a/apps/server/src/modules/room-membership/room-membership.module.ts
+++ b/apps/server/src/modules/room-membership/room-membership.module.ts
@@ -4,12 +4,13 @@ import { CqrsModule } from '@nestjs/cqrs';
 import { AuthorizationModule } from '../authorization';
 import { RoleModule } from '../role';
 import { RoomModule } from '../room/room.module';
+import { UserModule } from '../user';
 import { RoomMembershipRule } from './authorization/room-membership.rule';
 import { RoomMembershipRepo } from './repo/room-membership.repo';
 import { RoomMembershipService } from './service/room-membership.service';
 
 @Module({
-	imports: [AuthorizationModule, CqrsModule, GroupModule, RoleModule, RoomModule],
+	imports: [AuthorizationModule, CqrsModule, GroupModule, RoleModule, RoomModule, UserModule],
 	providers: [RoomMembershipService, RoomMembershipRepo, RoomMembershipRule],
 	exports: [RoomMembershipService],
 })
diff --git a/apps/server/src/modules/room-membership/service/room-membership.service.spec.ts b/apps/server/src/modules/room-membership/service/room-membership.service.spec.ts
index d9134cb2867..6f6b39139b2 100644
--- a/apps/server/src/modules/room-membership/service/room-membership.service.spec.ts
+++ b/apps/server/src/modules/room-membership/service/room-membership.service.spec.ts
@@ -1,13 +1,15 @@
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
-import { GroupService, GroupTypes } from '@modules/group';
-import { RoleService } from '@modules/role';
+import { MongoMemoryDatabaseModule } from '@infra/database';
+import { Group, GroupService, GroupTypes } from '@modules/group';
+import { RoleDto, RoleService } from '@modules/role';
+import { RoomService } from '@modules/room/domain';
 import { roomFactory } from '@modules/room/testing';
+import { schoolFactory } from '@modules/school/testing';
+import { UserService } from '@modules/user';
 import { BadRequestException } from '@nestjs/common/exceptions';
 import { Test, TestingModule } from '@nestjs/testing';
 import { RoleName } from '@shared/domain/interface';
-import { groupFactory, roleDtoFactory, userFactory } from '@shared/testing';
-import { MongoMemoryDatabaseModule } from '@src/infra/database';
-import { RoomService } from '@src/modules/room/domain';
+import { groupFactory, roleDtoFactory, roleFactory, userDoFactory, userFactory } from '@shared/testing';
 import { RoomMembershipAuthorizable } from '../do/room-membership-authorizable.do';
 import { RoomMembershipRepo } from '../repo/room-membership.repo';
 import { roomMembershipFactory } from '../testing';
@@ -20,6 +22,7 @@ describe('RoomMembershipService', () => {
 	let groupService: DeepMocked<GroupService>;
 	let roleService: DeepMocked<RoleService>;
 	let roomService: DeepMocked<RoomService>;
+	let userService: DeepMocked<UserService>;
 
 	beforeAll(async () => {
 		module = await Test.createTestingModule({
@@ -42,6 +45,10 @@ describe('RoomMembershipService', () => {
 					provide: RoomService,
 					useValue: createMock<RoomService>(),
 				},
+				{
+					provide: UserService,
+					useValue: createMock<UserService>(),
+				},
 			],
 		}).compile();
 
@@ -50,6 +57,7 @@ describe('RoomMembershipService', () => {
 		groupService = module.get(GroupService);
 		roleService = module.get(RoleService);
 		roomService = module.get(RoomService);
+		userService = module.get(UserService);
 	});
 
 	afterAll(async () => {
@@ -113,9 +121,14 @@ describe('RoomMembershipService', () => {
 		describe('when roomMembership exists', () => {
 			const setup = () => {
 				const user = userFactory.buildWithId();
-				const group = groupFactory.build({ type: GroupTypes.ROOM });
-				const room = roomFactory.build();
-				const roomMembership = roomMembershipFactory.build({ roomId: room.id, userGroupId: group.id });
+				const school = schoolFactory.build();
+				const group = groupFactory.build({ type: GroupTypes.ROOM, organizationId: school.id });
+				const room = roomFactory.build({ schoolId: school.id });
+				const roomMembership = roomMembershipFactory.build({
+					roomId: room.id,
+					userGroupId: group.id,
+					schoolId: school.id,
+				});
 
 				roomMembershipRepo.findByRoomId.mockResolvedValue(roomMembership);
 
@@ -136,6 +149,14 @@ describe('RoomMembershipService', () => {
 					{ userId: user.id, roleName: RoleName.ROOMEDITOR },
 				]);
 			});
+
+			it('should add user to school', async () => {
+				const { user, room } = setup();
+
+				await service.addMembersToRoom(room.id, [{ userId: user.id, roleName: RoleName.ROOMEDITOR }]);
+
+				expect(userService.addSecondarySchoolToUsers).toHaveBeenCalledWith([user.id], room.schoolId);
+			});
 		});
 	});
 
@@ -176,6 +197,7 @@ describe('RoomMembershipService', () => {
 
 				roomMembershipRepo.findByRoomId.mockResolvedValue(roomMembership);
 				groupService.findById.mockResolvedValue(group);
+				groupService.findGroups.mockResolvedValue({ total: 1, data: [group] });
 
 				return {
 					user,
@@ -193,6 +215,94 @@ describe('RoomMembershipService', () => {
 				expect(groupService.removeUsersFromGroup).toHaveBeenCalledWith(group.id, [user.id]);
 			});
 		});
+
+		const setupUserWithSecondarySchool = () => {
+			const secondarySchool = schoolFactory.build();
+			const otherSchool = schoolFactory.build();
+			const role = roleFactory.buildWithId({ name: RoleName.TEACHER });
+			const guestTeacher = roleFactory.buildWithId({ name: RoleName.GUESTTEACHER });
+			const externalUser = userDoFactory.buildWithId({
+				roles: [role],
+				secondarySchools: [{ schoolId: secondarySchool.id, role: new RoleDto(guestTeacher) }],
+			});
+
+			return { secondarySchool, externalUser, otherSchool };
+		};
+
+		const setupGroupAndRoom = (schoolId: string) => {
+			const group = groupFactory.build({ type: GroupTypes.ROOM });
+			const room = roomFactory.build({ schoolId });
+			const roomMembership = roomMembershipFactory.build({
+				roomId: room.id,
+				userGroupId: group.id,
+				schoolId,
+			});
+
+			return { group, room, roomMembership };
+		};
+
+		const mockGroupsAtSchoolAfterRemoval = (groups: Group[]) => {
+			groupService.findGroups.mockResolvedValue({ total: groups.length, data: groups });
+		};
+
+		it('should pass the schoolId of the room', async () => {
+			const { secondarySchool, externalUser } = setupUserWithSecondarySchool();
+
+			const roomEditorRole = roleFactory.buildWithId({ name: RoleName.ROOMEDITOR });
+
+			const { room, group, roomMembership } = setupGroupAndRoom(secondarySchool.id);
+			group.addUser({ userId: externalUser.id as string, roleId: roomEditorRole.id });
+
+			roomMembershipRepo.findByRoomId.mockResolvedValue(roomMembership);
+			groupService.findById.mockResolvedValue(group);
+			groupService.removeUsersFromGroup.mockResolvedValue(group);
+			mockGroupsAtSchoolAfterRemoval([]);
+
+			await service.removeMembersFromRoom(room.id, [externalUser.id as string]);
+
+			expect(groupService.findGroups).toHaveBeenCalledWith(expect.objectContaining({ schoolId: secondarySchool.id }));
+		});
+
+		describe('when after removal: user is not in any room of that secondary school', () => {
+			it('should remove user from secondary school', async () => {
+				const { secondarySchool, externalUser } = setupUserWithSecondarySchool();
+
+				const { room, group, roomMembership } = setupGroupAndRoom(secondarySchool.id);
+				const roomEditorRole = roleFactory.buildWithId({ name: RoleName.ROOMEDITOR });
+				group.addUser({ userId: externalUser.id as string, roleId: roomEditorRole.id });
+
+				roomMembershipRepo.findByRoomId.mockResolvedValue(roomMembership);
+				groupService.findById.mockResolvedValue(group);
+				groupService.removeUsersFromGroup.mockResolvedValue(group);
+				mockGroupsAtSchoolAfterRemoval([]);
+
+				await service.removeMembersFromRoom(room.id, [externalUser.id as string]);
+
+				expect(userService.removeSecondarySchoolFromUsers).toHaveBeenCalledWith([externalUser.id], secondarySchool.id);
+			});
+		});
+
+		describe('when after removal: user is still in a room of that secondary school', () => {
+			it('should not remove user from secondary school', async () => {
+				const { secondarySchool, externalUser } = setupUserWithSecondarySchool();
+
+				const roomEditorRole = roleFactory.buildWithId({ name: RoleName.ROOMEDITOR });
+
+				const { room, group, roomMembership } = setupGroupAndRoom(secondarySchool.id);
+				group.addUser({ userId: externalUser.id as string, roleId: roomEditorRole.id });
+				const { group: group2 } = setupGroupAndRoom(secondarySchool.id);
+				group2.addUser({ userId: externalUser.id as string, roleId: roomEditorRole.id });
+
+				roomMembershipRepo.findByRoomId.mockResolvedValue(roomMembership);
+				groupService.findById.mockResolvedValue(group);
+				groupService.removeUsersFromGroup.mockResolvedValue(group);
+				mockGroupsAtSchoolAfterRemoval([group2]);
+
+				await service.removeMembersFromRoom(room.id, [externalUser.id as string]);
+
+				expect(userService.removeSecondarySchoolFromUsers).not.toHaveBeenCalled();
+			});
+		});
 	});
 
 	describe('deleteRoomMembership', () => {
diff --git a/apps/server/src/modules/room-membership/service/room-membership.service.ts b/apps/server/src/modules/room-membership/service/room-membership.service.ts
index 75e6e6922eb..59fa6167c6d 100644
--- a/apps/server/src/modules/room-membership/service/room-membership.service.ts
+++ b/apps/server/src/modules/room-membership/service/room-membership.service.ts
@@ -1,6 +1,7 @@
 import { ObjectId } from '@mikro-orm/mongodb';
 import { Group, GroupService, GroupTypes } from '@modules/group';
 import { RoleDto, RoleService } from '@modules/role';
+import { UserService } from '@modules/user';
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { RoleName } from '@shared/domain/interface';
 import { EntityId } from '@shared/domain/types';
@@ -15,14 +16,15 @@ export class RoomMembershipService {
 		private readonly groupService: GroupService,
 		private readonly roomMembershipRepo: RoomMembershipRepo,
 		private readonly roleService: RoleService,
-		private readonly roomService: RoomService
+		private readonly roomService: RoomService,
+		private readonly userService: UserService
 	) {}
 
 	private async createNewRoomMembership(
 		roomId: EntityId,
 		userId: EntityId,
 		roleName: RoleName.ROOMEDITOR | RoleName.ROOMVIEWER
-	) {
+	): Promise<RoomMembership> {
 		const room = await this.roomService.getSingleRoom(roomId);
 
 		const group = await this.groupService.createGroup(
@@ -65,7 +67,7 @@ export class RoomMembershipService {
 		return roomMembershipAuthorizable;
 	}
 
-	public async deleteRoomMembership(roomId: EntityId) {
+	public async deleteRoomMembership(roomId: EntityId): Promise<void> {
 		const roomMembership = await this.roomMembershipRepo.findByRoomId(roomId);
 		if (roomMembership === null) return;
 
@@ -90,6 +92,9 @@ export class RoomMembershipService {
 
 		await this.groupService.addUsersToGroup(roomMembership.userGroupId, userIdsAndRoles);
 
+		const userIds = userIdsAndRoles.map((user) => user.userId);
+		await this.userService.addSecondarySchoolToUsers(userIds, roomMembership.schoolId);
+
 		return roomMembership.id;
 	}
 
@@ -101,6 +106,8 @@ export class RoomMembershipService {
 
 		const group = await this.groupService.findById(roomMembership.userGroupId);
 		await this.groupService.removeUsersFromGroup(group.id, userIds);
+
+		await this.handleGuestRoleRemoval(userIds, roomMembership.schoolId);
 	}
 
 	public async getRoomMembershipAuthorizablesByUserId(userId: EntityId): Promise<RoomMembershipAuthorizable[]> {
@@ -141,4 +148,15 @@ export class RoomMembershipService {
 
 		return roomMembershipAuthorizable;
 	}
+
+	private async handleGuestRoleRemoval(userIds: EntityId[], schoolId: EntityId): Promise<void> {
+		const { data: groups } = await this.groupService.findGroups({ userIds, groupTypes: [GroupTypes.ROOM], schoolId });
+
+		const userIdsInGroups = groups.flatMap((group) => group.users.map((groupUser) => groupUser.userId));
+		const removeUserIds = userIds.filter((userId) => !userIdsInGroups.includes(userId));
+
+		if (removeUserIds.length > 0) {
+			await this.userService.removeSecondarySchoolFromUsers(removeUserIds, schoolId);
+		}
+	}
 }
diff --git a/apps/server/src/modules/room/api/test/room-add-members.api.spec.ts b/apps/server/src/modules/room/api/test/room-add-members.api.spec.ts
index 5fab1cced7e..a1ed8579853 100644
--- a/apps/server/src/modules/room/api/test/room-add-members.api.spec.ts
+++ b/apps/server/src/modules/room/api/test/room-add-members.api.spec.ts
@@ -9,6 +9,7 @@ import {
 	cleanupCollections,
 	groupEntityFactory,
 	roleFactory,
+	schoolEntityFactory,
 } from '@shared/testing';
 import { GroupEntityTypes } from '@modules/group/entity/group.entity';
 import { roomMembershipEntityFactory } from '@src/modules/room-membership/testing/room-membership-entity.factory';
@@ -45,10 +46,13 @@ describe('Room Controller (API)', () => {
 
 	describe('PATCH /rooms/:roomId/members/add', () => {
 		const setupRoomWithMembers = async () => {
-			const room = roomEntityFactory.buildWithId();
-			const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher();
+			const school = schoolEntityFactory.buildWithId();
+			const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({ school });
 			const { teacherAccount: otherTeacherAccount, teacherUser: otherTeacherUser } =
 				UserAndAccountTestFactory.buildTeacher({ school: teacherUser.school });
+			const room = roomEntityFactory.buildWithId({ schoolId: teacherUser.school.id });
+			const teacherGuestRole = roleFactory.buildWithId({ name: RoleName.GUESTTEACHER });
+			const studentGuestRole = roleFactory.buildWithId({ name: RoleName.GUESTSTUDENT });
 			const role = roleFactory.buildWithId({
 				name: RoleName.ROOMEDITOR,
 				permissions: [Permission.ROOM_VIEW, Permission.ROOM_EDIT],
@@ -67,6 +71,8 @@ describe('Room Controller (API)', () => {
 				roomMemberships,
 				teacherAccount,
 				teacherUser,
+				teacherGuestRole,
+				studentGuestRole,
 				otherTeacherUser,
 				otherTeacherAccount,
 				userGroupEntity,
diff --git a/apps/server/src/modules/user/service/user.service.ts b/apps/server/src/modules/user/service/user.service.ts
index 6f0dc3f798a..811cedbfea8 100644
--- a/apps/server/src/modules/user/service/user.service.ts
+++ b/apps/server/src/modules/user/service/user.service.ts
@@ -56,14 +56,14 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		await this.eventBus.publish(new DataDeletedEvent(deletionRequestId, dataDeleted));
 	}
 
-	async getUserEntityWithRoles(userId: EntityId): Promise<User> {
+	public async getUserEntityWithRoles(userId: EntityId): Promise<User> {
 		// only roles required, no need for the other populates
 		const userWithRoles = await this.userRepo.findById(userId, true);
 
 		return userWithRoles;
 	}
 
-	async me(userId: EntityId): Promise<[User, string[]]> {
+	public async me(userId: EntityId): Promise<[User, string[]]> {
 		const user = await this.userRepo.findById(userId, true);
 		const permissions = user.resolvePermissions();
 
@@ -73,20 +73,20 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 	/**
 	 * @deprecated use {@link UserService.findById} instead
 	 */
-	async getUser(id: string): Promise<UserDto> {
+	public async getUser(id: string): Promise<UserDto> {
 		const userEntity = await this.userRepo.findById(id, true);
 		const userDto = UserMapper.mapFromEntityToDto(userEntity);
 
 		return userDto;
 	}
 
-	async findById(id: string): Promise<UserDO> {
+	public async findById(id: string): Promise<UserDO> {
 		const userDO = await this.userDORepo.findById(id, true);
 
 		return userDO;
 	}
 
-	async findByIds(ids: string[]): Promise<UserDO[]> {
+	public async findByIds(ids: string[]): Promise<UserDO[]> {
 		const userDOs = await this.userDORepo.findByIds(ids, true);
 
 		return userDOs;
@@ -98,25 +98,25 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return userDO;
 	}
 
-	async save(user: UserDO): Promise<UserDO> {
-		const savedUser: Promise<UserDO> = this.userDORepo.save(user);
+	public async save(user: UserDO): Promise<UserDO> {
+		const savedUser = await this.userDORepo.save(user);
 
 		return savedUser;
 	}
 
-	async saveAll(users: UserDO[]): Promise<UserDO[]> {
-		const savedUsers: Promise<UserDO[]> = this.userDORepo.saveAll(users);
+	public async saveAll(users: UserDO[]): Promise<UserDO[]> {
+		const savedUsers = await this.userDORepo.saveAll(users);
 
 		return savedUsers;
 	}
 
-	async findUsers(query: UserQuery, options?: IFindOptions<UserDO>): Promise<Page<UserDO>> {
+	public async findUsers(query: UserQuery, options?: IFindOptions<UserDO>): Promise<Page<UserDO>> {
 		const users: Page<UserDO> = await this.userDORepo.find(query, options);
 
 		return users;
 	}
 
-	async findBySchoolRole(
+	public async findBySchoolRole(
 		schoolId: EntityId,
 		roleName: RoleName,
 		options?: IFindOptions<UserDO>
@@ -127,7 +127,7 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return result;
 	}
 
-	async findPublicTeachersBySchool(schoolId: EntityId, options?: IFindOptions<UserDO>): Promise<Page<UserDO>> {
+	public async findPublicTeachersBySchool(schoolId: EntityId, options?: IFindOptions<UserDO>): Promise<Page<UserDO>> {
 		const discoverabilitySetting = this.configService.get<string>('TEACHER_VISIBILITY_FOR_EXTERNAL_TEAM_INVITATION');
 		if (discoverabilitySetting === 'disabled') {
 			return new Page<UserDO>([], 0);
@@ -147,7 +147,7 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return result;
 	}
 
-	async addSecondarySchoolToUsers(userIds: string[], schoolId: EntityId): Promise<void> {
+	public async addSecondarySchoolToUsers(userIds: string[], schoolId: EntityId): Promise<void> {
 		const users = await this.userDORepo.findByIds(userIds, true);
 		const guestStudent = await this.roleService.findByName(RoleName.GUESTSTUDENT);
 		const guestTeacher = await this.roleService.findByName(RoleName.GUESTTEACHER);
@@ -174,7 +174,7 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return Promise.resolve();
 	}
 
-	async removeSecondarySchoolFromUsers(userIds: string[], schoolId: EntityId): Promise<void> {
+	public async removeSecondarySchoolFromUsers(userIds: string[], schoolId: EntityId): Promise<void> {
 		const users = await this.userDORepo.findByIds(userIds, true);
 
 		users.forEach((user) => {
@@ -185,19 +185,19 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return Promise.resolve();
 	}
 
-	async findByExternalId(externalId: string, systemId: EntityId): Promise<UserDO | null> {
-		const user: Promise<UserDO | null> = this.userDORepo.findByExternalId(externalId, systemId);
+	public async findByExternalId(externalId: string, systemId: EntityId): Promise<UserDO | null> {
+		const user = await this.userDORepo.findByExternalId(externalId, systemId);
 
 		return user;
 	}
 
-	async findByEmail(email: string): Promise<UserDO[]> {
-		const user: Promise<UserDO[]> = this.userDORepo.findByEmail(email);
+	public async findByEmail(email: string): Promise<UserDO[]> {
+		const user = await this.userDORepo.findByEmail(email);
 
 		return user;
 	}
 
-	async getDisplayName(user: UserDO): Promise<string> {
+	public async getDisplayName(user: UserDO): Promise<string> {
 		const protectedRoles: RoleDto[] = await this.roleService.getProtectedRoles();
 		const isProtectedUser: boolean = user.roles.some(
 			(roleRef: RoleReference): boolean =>
@@ -209,7 +209,7 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		return displayName;
 	}
 
-	async patchLanguage(userId: EntityId, newLanguage: LanguageType): Promise<boolean> {
+	public async patchLanguage(userId: EntityId, newLanguage: LanguageType): Promise<boolean> {
 		this.checkAvailableLanguages(newLanguage);
 		const user = await this.userRepo.findById(userId);
 		user.language = newLanguage;
@@ -281,7 +281,7 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 	}
 
 	public async getParentEmailsFromUser(userId: EntityId): Promise<string[]> {
-		const parentEmails = this.userRepo.getParentEmailsFromUser(userId);
+		const parentEmails = await this.userRepo.getParentEmailsFromUser(userId);
 
 		return parentEmails;
 	}
@@ -293,7 +293,9 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 	}
 
 	public async findMultipleByExternalIds(externalIds: string[]): Promise<string[]> {
-		return this.userRepo.findByExternalIds(externalIds);
+		const userIds = await this.userRepo.findByExternalIds(externalIds);
+
+		return userIds;
 	}
 
 	public async updateLastSyncedAt(userIds: string[]): Promise<void> {
@@ -326,7 +328,8 @@ export class UserService implements DeletionService, IEventHandler<UserDeletedEv
 		const unsyncedForMiliseconds = unsyncedForMinutes * 60000;
 		const differenceBetweenCurrentDateAndUnsyncedTime = new Date().getTime() - unsyncedForMiliseconds;
 		const dateOfLastSyncToBeLookedFrom = new Date(differenceBetweenCurrentDateAndUnsyncedTime);
-		return this.userRepo.findUnsynchronizedUserIds(dateOfLastSyncToBeLookedFrom);
+		const userIds = await this.userRepo.findUnsynchronizedUserIds(dateOfLastSyncToBeLookedFrom);
+		return userIds;
 	}
 
 	public async removeCalendarEvents(userId: EntityId): Promise<DomainDeletionReport> {
diff --git a/apps/server/src/shared/repo/user/user.repo.ts b/apps/server/src/shared/repo/user/user.repo.ts
index 126dbabd99a..7b6fee3bf4e 100644
--- a/apps/server/src/shared/repo/user/user.repo.ts
+++ b/apps/server/src/shared/repo/user/user.repo.ts
@@ -121,16 +121,16 @@ export class UserRepo extends BaseRepo<User> {
 		return users;
 	}
 
-	public async findByExternalIds(externalIds: string[]): Promise<string[]> {
+	public async findByExternalIds(externalIds: EntityId[]): Promise<EntityId[]> {
 		const foundUsers = await this._em.find(
 			User,
 			{ externalId: { $in: externalIds } },
 			{ fields: ['id', 'externalId'] }
 		);
 
-		const users = foundUsers.map(({ id }) => id);
+		const userIds = foundUsers.map(({ id }) => id);
 
-		return users;
+		return userIds;
 	}
 
 	public async updateAllUserByLastSyncedAt(userIds: string[]): Promise<void> {