diff --git a/src/modules/rolle/api/rolle-name-query.param.ts b/src/modules/rolle/api/rolle-name-query.param.ts
index 607fea1e1..35b647bf4 100644
--- a/src/modules/rolle/api/rolle-name-query.param.ts
+++ b/src/modules/rolle/api/rolle-name-query.param.ts
@@ -1,7 +1,9 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsString, IsOptional } from 'class-validator';
+import { IsString, IsOptional, IsEnum } from 'class-validator';
 import { AutoMap } from '@automapper/classes';
 import { PagedQueryParams } from '../../../shared/paging/index.js';
+import { ScopeOrder } from '../../../shared/persistence/scope.enums.js';
+import { RollenSort } from '../domain/rolle.enums.js';
 
 export class RolleNameQueryParams extends PagedQueryParams {
     @AutoMap()
@@ -13,4 +15,24 @@ export class RolleNameQueryParams extends PagedQueryParams {
         nullable: false,
     })
     public readonly searchStr?: string;
+
+    @IsOptional()
+    @IsEnum(ScopeOrder)
+    @ApiProperty({
+        enum: ScopeOrder,
+        required: false,
+        nullable: true,
+        description: 'Order to sort by.',
+    })
+    public readonly sortOrder?: ScopeOrder;
+
+    @IsOptional()
+    @IsEnum(RollenSort)
+    @ApiProperty({
+        enum: RollenSort,
+        required: false,
+        nullable: true,
+        description: 'Field to sort by.',
+    })
+    public readonly sortField?: RollenSort;
 }
diff --git a/src/modules/rolle/api/rolle-with-serviceprovider.response.ts b/src/modules/rolle/api/rolle-with-serviceprovider.response.ts
index 56e6e134e..8cd801de4 100644
--- a/src/modules/rolle/api/rolle-with-serviceprovider.response.ts
+++ b/src/modules/rolle/api/rolle-with-serviceprovider.response.ts
@@ -4,6 +4,7 @@ import { ServiceProvider } from '../../service-provider/domain/service-provider.
 import { Rolle } from '../domain/rolle.js';
 import { RolleResponse } from './rolle.response.js';
 import { ServiceProviderIdNameResponse } from './serviceprovider-id-name.response.js';
+import { RollenMerkmal } from '../domain/rolle.enums.js';
 
 export class RolleWithServiceProvidersResponse extends RolleResponse {
     @ApiProperty({ type: ServiceProviderIdNameResponse, isArray: true })
@@ -12,6 +13,7 @@ export class RolleWithServiceProvidersResponse extends RolleResponse {
     public constructor(
         rolle: Rolle<true>,
         serviceProviders: ServiceProvider<true>[],
+        sortedMerkmale?: RollenMerkmal[],
         administeredBySchulstrukturknotenName?: string,
         administeredBySchulstrukturknotenKennung?: string,
     ) {
@@ -19,5 +21,8 @@ export class RolleWithServiceProvidersResponse extends RolleResponse {
         this.serviceProviders = serviceProviders.map(
             (sp: ServiceProvider<true>) => new ServiceProviderIdNameResponse(sp),
         );
+        if (sortedMerkmale) {
+            this.merkmale = sortedMerkmale;
+        }
     }
 }
diff --git a/src/modules/rolle/api/rolle.controller.integration-spec.ts b/src/modules/rolle/api/rolle.controller.integration-spec.ts
index aa316493b..eaeda90c1 100644
--- a/src/modules/rolle/api/rolle.controller.integration-spec.ts
+++ b/src/modules/rolle/api/rolle.controller.integration-spec.ts
@@ -27,7 +27,6 @@ import { ServiceProvider } from '../../service-provider/domain/service-provider.
 import { RolleServiceProviderQueryParams } from './rolle-service-provider.query.params.js';
 import { RolleWithServiceProvidersResponse } from './rolle-with-serviceprovider.response.js';
 import { PagedResponse } from '../../../shared/paging/index.js';
-import { ServiceProviderIdNameResponse } from './serviceprovider-id-name.response.js';
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import { PersonPermissionsRepo } from '../../authentication/domain/person-permission.repo.js';
 import { Observable } from 'rxjs';
@@ -312,63 +311,229 @@ describe('Rolle API', () => {
             expect(pagedResponse.items).toContainEqual(expect.objectContaining({ name: testRolle.name }));
         });
 
-        it('should return rollen with serviceproviders', async () => {
-            const [sp1, sp2, sp3]: [ServiceProvider<true>, ServiceProvider<true>, ServiceProvider<true>] =
-                await Promise.all([
-                    serviceProviderRepo.save(DoFactory.createServiceProvider(false)),
-                    serviceProviderRepo.save(DoFactory.createServiceProvider(false)),
-                    serviceProviderRepo.save(DoFactory.createServiceProvider(false)),
-                ]);
+        it('should sort rollen by first service provider name in des order', async () => {
+            const [sp1, sp2]: [ServiceProvider<true>, ServiceProvider<true>] = await Promise.all([
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'A Provider' })),
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'B Provider' })),
+            ]);
 
             const orgaIds: string[] = (
                 await Promise.all([
-                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp1.id] })),
-                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp2.id, sp3.id] })),
-                    rolleRepo.save(DoFactory.createRolle(false)),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp1.id, sp2.id] })),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp2.id] })),
                 ])
             ).map((r: Rolle<true>) => r.administeredBySchulstrukturknoten);
 
-            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({ all: false, orgaIds });
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds,
+            });
 
             const response: Response = await request(app.getHttpServer() as App)
                 .get('/rolle')
+                .query({ sortField: 'serviceProviders', sortOrder: 'desc' })
                 .send();
 
             expect(response.status).toBe(200);
             expect(response.body).toBeInstanceOf(Object);
+
+            const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
+                response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items).toBeDefined();
+            expect(pagedResponse.items).toHaveLength(2);
+
+            expect(pagedResponse.items[0]?.serviceProviders[0]?.name).toBe('B Provider');
+            expect(pagedResponse.items[0]?.serviceProviders[1]?.name).toBe('A Provider');
+            expect(pagedResponse.items[1]?.serviceProviders[0]?.name).toBe('B Provider');
+        });
+
+        it('should sort rollen by administeredBySchulstrukturknotenName in asc order', async () => {
+            const org1: OrganisationEntity = new OrganisationEntity();
+            org1.name = 'A School';
+            const org2: OrganisationEntity = new OrganisationEntity();
+            org2.name = 'B School';
+            await em.persistAndFlush([org1, org2]);
+
+            await rolleRepo.save(DoFactory.createRolle(false, { administeredBySchulstrukturknoten: org1.id }));
+            await rolleRepo.save(DoFactory.createRolle(false, { administeredBySchulstrukturknoten: org2.id }));
+
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds: [org1.id, org2.id],
+            });
+
+            const response: Response = await request(app.getHttpServer() as App)
+                .get('/rolle')
+                .query({ sortField: 'administeredBySchulstrukturknotenName', sortOrder: 'asc' })
+                .send();
+
+            const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
+                response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items[0]?.administeredBySchulstrukturknotenName).toBe('A School');
+            expect(pagedResponse.items[1]?.administeredBySchulstrukturknotenName).toBe('B School');
+        });
+
+        it('should sort rollen by first service provider name in desc order', async () => {
+            const [sp1, sp2]: [ServiceProvider<true>, ServiceProvider<true>] = await Promise.all([
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'A Provider' })),
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'B Provider' })),
+            ]);
+            const orgaIds: string[] = (
+                await Promise.all([
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp1.id, sp2.id] })),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp2.id] })),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [] })),
+                ])
+            ).map((r: Rolle<true>) => r.administeredBySchulstrukturknoten);
+
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds,
+            });
+
+            const response: Response = await request(app.getHttpServer() as App)
+                .get('/rolle')
+                .query({ sortField: 'serviceProviders', sortOrder: 'desc' })
+                .send();
+
             const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
                 response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items).toBeDefined();
             expect(pagedResponse.items).toHaveLength(3);
 
-            pagedResponse.items.forEach((item: RolleWithServiceProvidersResponse) => {
-                item.serviceProviders.sort((a: ServiceProviderIdNameResponse, b: ServiceProviderIdNameResponse) =>
-                    a.id.localeCompare(b.id),
-                );
+            expect(pagedResponse.items[0]?.serviceProviders[0]?.name).toBe('B Provider');
+            expect(pagedResponse.items[1]?.serviceProviders[0]?.name).toBe('B Provider');
+            expect(pagedResponse.items[2]?.serviceProviders[0]?.name).toBe(undefined);
+        });
+        it('should sort rollen by first service provider name in asc order', async () => {
+            const [sp1, sp2]: [ServiceProvider<true>, ServiceProvider<true>] = await Promise.all([
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'A Provider' })),
+                serviceProviderRepo.save(DoFactory.createServiceProvider(false, { name: 'B Provider' })),
+            ]);
+            const orgaIds: string[] = (
+                await Promise.all([
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp1.id, sp2.id] })),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [sp2.id] })),
+                    rolleRepo.save(DoFactory.createRolle(false, { serviceProviderIds: [] })),
+                ])
+            ).map((r: Rolle<true>) => r.administeredBySchulstrukturknoten);
+
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds,
             });
 
-            expect(pagedResponse.items).toContainEqual(
-                expect.objectContaining({ serviceProviders: [{ id: sp1.id, name: sp1.name }] }),
+            const response: Response = await request(app.getHttpServer() as App)
+                .get('/rolle')
+                .query({ sortField: 'serviceProviders', sortOrder: 'asc' })
+                .send();
+
+            const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
+                response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items).toBeDefined();
+            expect(pagedResponse.items).toHaveLength(3);
+
+            expect(pagedResponse.items[0]?.serviceProviders[0]?.name).toBe(undefined);
+
+            expect(pagedResponse.items[1]?.serviceProviders[0]?.name).toBe('A Provider');
+            expect(pagedResponse.items[2]?.serviceProviders[0]?.name).toBe('B Provider');
+        });
+
+        it('should sort rollen by merkmale in desc order', async () => {
+            const rolle1: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, { merkmale: [RollenMerkmal.KOPERS_PFLICHT] }),
             );
-            expect(pagedResponse.items).toContainEqual(
-                expect.objectContaining({
-                    serviceProviders: [
-                        { id: sp2.id, name: sp2.name },
-                        { id: sp3.id, name: sp3.name },
-                    ].sort(
-                        (
-                            a: {
-                                id: string;
-                                name: string;
-                            },
-                            b: {
-                                id: string;
-                                name: string;
-                            },
-                        ) => a.id.localeCompare(b.id),
-                    ),
+            const rolle2: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [RollenMerkmal.BEFRISTUNG_PFLICHT, RollenMerkmal.KOPERS_PFLICHT],
                 }),
             );
-            expect(pagedResponse.items).toContainEqual(expect.objectContaining({ serviceProviders: [] }));
+            const rolle3: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [],
+                }),
+            );
+            const rolle4: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [],
+                }),
+            );
+
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds: [
+                    rolle1.administeredBySchulstrukturknoten,
+                    rolle2.administeredBySchulstrukturknoten,
+                    rolle3.administeredBySchulstrukturknoten,
+                    rolle4.administeredBySchulstrukturknoten,
+                ],
+            });
+
+            const response: Response = await request(app.getHttpServer() as App)
+                .get('/rolle')
+                .query({ sortField: 'merkmale', sortOrder: 'desc' })
+                .send();
+
+            const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
+                response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items).toBeDefined();
+            expect(pagedResponse.items).toHaveLength(4);
+
+            expect(pagedResponse.items[0]?.merkmale[0]).toBe(RollenMerkmal.KOPERS_PFLICHT);
+            expect(pagedResponse.items[1]?.merkmale[1]).toBe(RollenMerkmal.BEFRISTUNG_PFLICHT);
+            expect(pagedResponse.items[2]?.merkmale[0]).toBe(undefined);
+            expect(pagedResponse.items[3]?.merkmale[0]).toBe(undefined);
+        });
+        it('should sort rollen by merkmale in asc order', async () => {
+            const rolle1: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, { merkmale: [RollenMerkmal.KOPERS_PFLICHT] }),
+            );
+            const rolle2: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [RollenMerkmal.BEFRISTUNG_PFLICHT, RollenMerkmal.KOPERS_PFLICHT],
+                }),
+            );
+            const rolle3: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [],
+                }),
+            );
+            const rolle4: Rolle<true> = await rolleRepo.save(
+                DoFactory.createRolle(false, {
+                    merkmale: [],
+                }),
+            );
+
+            personPermissionsMock.getOrgIdsWithSystemrecht.mockResolvedValue({
+                all: false,
+                orgaIds: [
+                    rolle1.administeredBySchulstrukturknoten,
+                    rolle2.administeredBySchulstrukturknoten,
+                    rolle3.administeredBySchulstrukturknoten,
+                    rolle4.administeredBySchulstrukturknoten,
+                ],
+            });
+
+            const response: Response = await request(app.getHttpServer() as App)
+                .get('/rolle')
+                .query({ sortField: 'merkmale', sortOrder: 'asc' })
+                .send();
+
+            const pagedResponse: PagedResponse<RolleWithServiceProvidersResponse> =
+                response.body as PagedResponse<RolleWithServiceProvidersResponse>;
+
+            expect(pagedResponse.items).toBeDefined();
+            expect(pagedResponse.items).toHaveLength(4);
+
+            expect(pagedResponse.items[2]?.merkmale[0]).toBe(RollenMerkmal.BEFRISTUNG_PFLICHT);
+            expect(pagedResponse.items[3]?.merkmale[0]).toBe(RollenMerkmal.KOPERS_PFLICHT);
+            expect(pagedResponse.items[0]?.merkmale[0]).toBe(undefined);
+            expect(pagedResponse.items[1]?.merkmale[0]).toBe(undefined);
         });
     });
 
diff --git a/src/modules/rolle/api/rolle.controller.ts b/src/modules/rolle/api/rolle.controller.ts
index 73b09fc41..83aefa078 100644
--- a/src/modules/rolle/api/rolle.controller.ts
+++ b/src/modules/rolle/api/rolle.controller.ts
@@ -60,6 +60,8 @@ import { AuthenticationExceptionFilter } from '../../authentication/api/authenti
 import { DbiamRolleError } from './dbiam-rolle.error.js';
 import { OrganisationRepository } from '../../organisation/persistence/organisation.repository.js';
 import { Organisation } from '../../organisation/domain/organisation.js';
+import { RollenMerkmal, RollenSort } from '../domain/rolle.enums.js';
+import { ScopeOrder } from '../../../shared/persistence/scope.enums.js';
 
 @UseFilters(new SchulConnexValidationErrorFilter(), new RolleExceptionFilter(), new AuthenticationExceptionFilter())
 @ApiTags('rolle')
@@ -90,23 +92,35 @@ export class RolleController {
         @Query() queryParams: RolleNameQueryParams,
         @Permissions() permissions: PersonPermissions,
     ): Promise<PagedResponse<RolleWithServiceProvidersResponse>> {
+        const shouldSortBySchulstrukturknotenName: boolean =
+            queryParams.sortField === RollenSort.ADMINISTERED_BY_SCHULSTRUKTURKNOTEN_NAME;
+        const shouldSortByServiceProviders: boolean = queryParams.sortField === RollenSort.SERVICE_PROVIDERS;
+        const shouldSortByMerkmale: boolean = queryParams.sortField === RollenSort.MERKMALE;
+
         const [rollen, total]: [Option<Rolle<true>[]>, number] = await this.rolleRepo.findRollenAuthorized(
             permissions,
             false,
             queryParams.searchStr,
             queryParams.limit,
             queryParams.offset,
+            shouldSortBySchulstrukturknotenName || shouldSortByServiceProviders || shouldSortByMerkmale
+                ? undefined
+                : queryParams.sortField,
+            shouldSortBySchulstrukturknotenName || shouldSortByServiceProviders || shouldSortByMerkmale
+                ? undefined
+                : queryParams.sortOrder,
         );
 
         if (!rollen || rollen.length === 0) {
             const pagedRolleWithServiceProvidersResponse: Paged<RolleWithServiceProvidersResponse> = {
                 total: 0,
-                offset: 0,
+                offset: queryParams.offset ?? 0,
                 limit: queryParams.limit ?? 0,
                 items: [],
             };
             return new PagedResponse(pagedRolleWithServiceProvidersResponse);
         }
+
         const administeredBySchulstrukturknotenIds: string[] = rollen.map(
             (r: Rolle<true>) => r.administeredBySchulstrukturknoten,
         );
@@ -114,24 +128,53 @@ export class RolleController {
             administeredBySchulstrukturknotenIds,
         );
         const serviceProviders: ServiceProvider<true>[] = await this.serviceProviderRepo.find();
-        const rollenWithServiceProvidersResponses: RolleWithServiceProvidersResponse[] = rollen.map(
-            (r: Rolle<true>) => {
-                const sps: ServiceProvider<true>[] = r.serviceProviderIds
-                    .map((id: string) => serviceProviders.find((sp: ServiceProvider<true>) => sp.id === id))
-                    .filter(Boolean) as ServiceProvider<true>[];
-
-                const administeredBySchulstrukturknoten: Organisation<true> | undefined = administeredOrganisations.get(
-                    r.administeredBySchulstrukturknoten,
-                );
-
-                return new RolleWithServiceProvidersResponse(
-                    r,
-                    sps,
-                    administeredBySchulstrukturknoten?.name,
-                    administeredBySchulstrukturknoten?.kennung,
-                );
-            },
-        );
+        let rollenWithServiceProvidersResponses: RolleWithServiceProvidersResponse[] = rollen.map((r: Rolle<true>) => {
+            let sps: ServiceProvider<true>[] = r.serviceProviderIds
+                .map((id: string) => serviceProviders.find((sp: ServiceProvider<true>) => sp.id === id))
+                .filter(Boolean) as ServiceProvider<true>[];
+
+            sps = sps.sort((a: ServiceProvider<true>, b: ServiceProvider<true>) =>
+                queryParams.sortOrder === ScopeOrder.ASC ? a.name.localeCompare(b.name) : b.name.localeCompare(a.name),
+            );
+
+            const sortedMerkmale: RollenMerkmal[] = r.merkmale.sort((a: RollenMerkmal, b: RollenMerkmal) =>
+                queryParams.sortOrder === ScopeOrder.ASC ? a.localeCompare(b) : b.localeCompare(a),
+            );
+
+            const administeredBySchulstrukturknoten: Organisation<true> | undefined = administeredOrganisations.get(
+                r.administeredBySchulstrukturknoten,
+            );
+
+            return new RolleWithServiceProvidersResponse(
+                r,
+                sps,
+                sortedMerkmale,
+                administeredBySchulstrukturknoten?.name,
+                administeredBySchulstrukturknoten?.kennung,
+            );
+        });
+
+        const sortByField = (fieldGetter: (item: RolleWithServiceProvidersResponse) => string | undefined): void => {
+            rollenWithServiceProvidersResponses = rollenWithServiceProvidersResponses.sort(
+                (a: RolleWithServiceProvidersResponse, b: RolleWithServiceProvidersResponse) => {
+                    const fieldA: string = fieldGetter(a) ?? '';
+                    const fieldB: string = fieldGetter(b) ?? '';
+                    return queryParams.sortOrder === ScopeOrder.ASC
+                        ? fieldA.localeCompare(fieldB)
+                        : fieldB.localeCompare(fieldA);
+                },
+            );
+        };
+
+        if (shouldSortBySchulstrukturknotenName) {
+            sortByField((item: RolleWithServiceProvidersResponse) => item.administeredBySchulstrukturknotenName);
+        } else if (shouldSortByServiceProviders) {
+            // sorting for the first serviceProvider
+            sortByField((item: RolleWithServiceProvidersResponse) => item.serviceProviders[0]?.name);
+        } else if (shouldSortByMerkmale) {
+            sortByField((item: RolleWithServiceProvidersResponse) => item?.merkmale[0]);
+        }
+
         const pagedRolleWithServiceProvidersResponse: Paged<RolleWithServiceProvidersResponse> = {
             total: total,
             offset: queryParams.offset ?? 0,
diff --git a/src/modules/rolle/domain/rolle.enums.ts b/src/modules/rolle/domain/rolle.enums.ts
index 11dda6b64..c6a39770c 100644
--- a/src/modules/rolle/domain/rolle.enums.ts
+++ b/src/modules/rolle/domain/rolle.enums.ts
@@ -26,3 +26,11 @@ export enum RollenSystemRecht {
     MIGRATION_DURCHFUEHREN = 'MIGRATION_DURCHFUEHREN',
     PERSON_SYNCHRONISIEREN = 'PERSON_SYNCHRONISIEREN',
 }
+
+export enum RollenSort {
+    ADMINISTERED_BY_SCHULSTRUKTURKNOTEN_NAME = 'administeredBySchulstrukturknotenName',
+    NAME = 'name',
+    ROLLENART = 'rollenart',
+    SERVICE_PROVIDERS = 'serviceProviders',
+    MERKMALE = 'merkmale',
+}
diff --git a/src/modules/rolle/repo/rolle.repo.spec.ts b/src/modules/rolle/repo/rolle.repo.spec.ts
index 296751a1c..23f5bbf2e 100644
--- a/src/modules/rolle/repo/rolle.repo.spec.ts
+++ b/src/modules/rolle/repo/rolle.repo.spec.ts
@@ -21,8 +21,9 @@ import { PersonPermissions } from '../../authentication/domain/person-permission
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import { OrganisationID } from '../../../shared/types/index.js';
 import { DomainError } from '../../../shared/error/domain.error.js';
-import { RollenMerkmal, RollenSystemRecht } from '../domain/rolle.enums.js';
+import { RollenMerkmal, RollenSort, RollenSystemRecht } from '../domain/rolle.enums.js';
 import { UpdateMerkmaleError } from '../domain/update-merkmale.error.js';
+import { ScopeOrder } from '../../../shared/persistence/scope.enums.js';
 
 describe('RolleRepo', () => {
     let module: TestingModule;
@@ -352,6 +353,61 @@ describe('RolleRepo', () => {
             expect(rolleResult).toHaveLength(1);
             expect(total).toBe(1);
         });
+        it('should order the rollen by the given sortField in ascending order', async () => {
+            const organisationId: OrganisationID = faker.string.uuid();
+
+            await sut.save(
+                DoFactory.createRolle(false, { administeredBySchulstrukturknoten: organisationId, name: 'A' }),
+            );
+            await sut.save(
+                DoFactory.createRolle(false, { administeredBySchulstrukturknoten: organisationId, name: 'B' }),
+            );
+
+            const permissions: DeepMocked<PersonPermissions> = createMock<PersonPermissions>();
+            permissions.getOrgIdsWithSystemrecht.mockResolvedValueOnce({ all: false, orgaIds: [organisationId] });
+
+            const [rolleResultAsc]: [Option<Rolle<true>[]>, number] = await sut.findRollenAuthorized(
+                permissions,
+                false,
+                undefined,
+                10,
+                0,
+                'name' as RollenSort,
+                ScopeOrder.ASC,
+            );
+
+            expect(rolleResultAsc?.length).toBe(2);
+            expect(rolleResultAsc?.[0]?.name).toBe('A');
+            expect(rolleResultAsc?.[1]?.name).toBe('B');
+        });
+
+        it('should order the rollen by the given sortField in descending order', async () => {
+            const organisationId: OrganisationID = faker.string.uuid();
+
+            await sut.save(
+                DoFactory.createRolle(false, { administeredBySchulstrukturknoten: organisationId, name: 'A' }),
+            );
+            await sut.save(
+                DoFactory.createRolle(false, { administeredBySchulstrukturknoten: organisationId, name: 'B' }),
+            );
+
+            const permissions: DeepMocked<PersonPermissions> = createMock<PersonPermissions>();
+            permissions.getOrgIdsWithSystemrecht.mockResolvedValueOnce({ all: false, orgaIds: [organisationId] });
+
+            const [rolleResultDesc]: [Option<Rolle<true>[]>, number] = await sut.findRollenAuthorized(
+                permissions,
+                false,
+                undefined,
+                10,
+                0,
+                'name' as RollenSort,
+                ScopeOrder.DESC,
+            );
+
+            expect(rolleResultDesc?.length).toBe(2);
+            expect(rolleResultDesc?.[0]?.name).toBe('B');
+            expect(rolleResultDesc?.[1]?.name).toBe('A');
+        });
     });
     describe('findByName', () => {
         it('should return the rolle', async () => {
diff --git a/src/modules/rolle/repo/rolle.repo.ts b/src/modules/rolle/repo/rolle.repo.ts
index 929c804e5..49e88dcc5 100644
--- a/src/modules/rolle/repo/rolle.repo.ts
+++ b/src/modules/rolle/repo/rolle.repo.ts
@@ -8,7 +8,7 @@ import {
 } from '@mikro-orm/core';
 import { Injectable } from '@nestjs/common';
 
-import { RollenMerkmal, RollenSystemRecht } from '../domain/rolle.enums.js';
+import { RollenMerkmal, RollenSort, RollenSystemRecht } from '../domain/rolle.enums.js';
 import { Rolle } from '../domain/rolle.js';
 import { RolleMerkmalEntity } from '../entity/rolle-merkmal.entity.js';
 import { RolleEntity } from '../entity/rolle.entity.js';
@@ -25,6 +25,7 @@ import { RolleHatPersonenkontexteError } from '../domain/rolle-hat-personenkonte
 
 import { ServiceProvider } from '../../service-provider/domain/service-provider.js';
 import { ServiceProviderEntity } from '../../service-provider/repo/service-provider.entity.js';
+import { ScopeOrder } from '../../../shared/persistence/scope.enums.js';
 
 /**
  * @deprecated Not for use outside of rolle-repo, export will be removed at a later date
@@ -225,6 +226,8 @@ export class RolleRepo {
         searchStr?: string,
         limit?: number,
         offset?: number,
+        sortField?: RollenSort,
+        sortOrder?: ScopeOrder,
     ): Promise<[Option<Rolle<true>[]>, number]> {
         const orgIdsWithRecht: PermittedOrgas = await permissions.getOrgIdsWithSystemrecht(
             [RollenSystemRecht.ROLLEN_VERWALTEN],
@@ -249,6 +252,7 @@ export class RolleRepo {
                 exclude: ['serviceProvider.serviceProvider.logo'] as const,
                 limit: limit,
                 offset: offset,
+                orderBy: sortField ? { [sortField]: sortOrder === ScopeOrder.ASC ? 'ASC' : 'DESC' } : undefined,
             },
         );