diff --git a/apps/api/src/mentors-profile/XXXXXX-add-deleted-at-to-mentor-profiles.ts b/apps/api/src/mentors-profile/XXXXXX-add-deleted-at-to-mentor-profiles.ts
new file mode 100644
index 0000000..8365c6a
--- /dev/null
+++ b/apps/api/src/mentors-profile/XXXXXX-add-deleted-at-to-mentor-profiles.ts
@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
+
+export class AddDeletedAtToMentorProfiles1234567890 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.addColumn(
+      'mentor_profiles',
+      new TableColumn({
+        name: 'deleted_at',
+        type: 'timestamp',
+        isNullable: true,
+        default: null,
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropColumn('mentor_profiles', 'deleted_at');
+  }
+}
\ No newline at end of file
diff --git a/apps/api/src/mentors-profile/dto/query-mentors-profile.dto.ts b/apps/api/src/mentors-profile/dto/query-mentors-profile.dto.ts
new file mode 100644
index 0000000..678991b
--- /dev/null
+++ b/apps/api/src/mentors-profile/dto/query-mentors-profile.dto.ts
@@ -0,0 +1,56 @@
+import { IsOptional, IsString, IsNumber, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class QueryMentorProfileDto {
+  @ApiPropertyOptional({ 
+    description: 'Filter by expertise/headline (partial match)',
+    example: 'JavaScript' 
+  })
+  @IsOptional()
+  @IsString()
+  expertise?: string;
+
+  @ApiPropertyOptional({ 
+    description: 'Minimum hourly rate in NGN',
+    example: 5000 
+  })
+  @IsOptional()
+  @IsNumber()
+  @Type(() => Number)
+  @Min(0)
+  minPrice?: number;
+
+  @ApiPropertyOptional({ 
+    description: 'Maximum hourly rate in NGN',
+    example: 50000 
+  })
+  @IsOptional()
+  @IsNumber()
+  @Type(() => Number)
+  @Min(0)
+  maxPrice?: number;
+
+  @ApiPropertyOptional({ 
+    description: 'Page number',
+    example: 1,
+    default: 1 
+  })
+  @IsOptional()
+  @IsNumber()
+  @Type(() => Number)
+  @Min(1)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ 
+    description: 'Items per page',
+    example: 10,
+    default: 10 
+  })
+  @IsOptional()
+  @IsNumber()
+  @Type(() => Number)
+  @Min(1)
+  @Max(100)
+  limit?: number = 10;
+}
\ No newline at end of file
diff --git a/apps/api/src/mentors-profile/entities/mentors-profile.entity.ts b/apps/api/src/mentors-profile/entities/mentors-profile.entity.ts
index 1fa2fde..92614f1 100644
--- a/apps/api/src/mentors-profile/entities/mentors-profile.entity.ts
+++ b/apps/api/src/mentors-profile/entities/mentors-profile.entity.ts
@@ -1,9 +1,11 @@
+// src/mentors-profile/entities/mentors-profile.entity.ts
 import {
   Entity,
   PrimaryGeneratedColumn,
   Column,
   CreateDateColumn,
   UpdateDateColumn,
+  DeleteDateColumn,
   OneToOne,
   JoinColumn,
   Index,
@@ -56,4 +58,7 @@ export class MentorProfile {
 
   @UpdateDateColumn({ name: 'updated_at' })
   updatedAt!: Date;
-}
+
+  @DeleteDateColumn({ name: 'deleted_at', nullable: true })
+  deletedAt?: Date;
+}
\ No newline at end of file
diff --git a/apps/api/src/mentors-profile/mentors-profile.controller.ts b/apps/api/src/mentors-profile/mentors-profile.controller.ts
index 6b4a521..f95ab20 100644
--- a/apps/api/src/mentors-profile/mentors-profile.controller.ts
+++ b/apps/api/src/mentors-profile/mentors-profile.controller.ts
@@ -1,10 +1,14 @@
-// src/mentors/mentors.controller.ts
+// src/mentors-profile/mentors-profile.controller.ts
 import {
   Controller,
   Get,
   Post,
   Put,
+  Patch,
+  Delete,
   Body,
+  Param,
+  Query,
   UseGuards,
   Request,
   HttpCode,
@@ -15,13 +19,14 @@ import {
   ApiOperation,
   ApiResponse,
   ApiBearerAuth,
-  ApiBody,
+  ApiParam,
+  ApiQuery,
 } from '@nestjs/swagger';
 import { MentorsService } from './mentors-profile.service';
 import { MentorProfileResponseDto } from './dto/mentor-profile-response';
 import { CreateMentorProfileDto } from './dto/create-mentors-profile.dto';
 import { UpdateMentorProfileDto } from './dto/update-mentors-profile.dto';
-// Assuming you have a JwtAuthGuard
+import { QueryMentorProfileDto } from './dto/query-mentors-profile.dto';
 // import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
 
 @ApiTags('Mentors')
@@ -46,10 +51,23 @@ export class MentorsController {
     @Request() req: any,
     @Body() dto: CreateMentorProfileDto,
   ): Promise<MentorProfileResponseDto> {
-    const userId = req.user?.id || 'test-user-id'; // Replace with actual user from JWT
+    const userId = req.user?.id || 'test-user-id';
     return this.mentorsService.createProfile(userId, dto);
   }
 
+  @Get()
+  @ApiOperation({ 
+    summary: 'List all approved mentor profiles with filters',
+    description: 'Public endpoint to list approved mentors. Supports filtering by expertise and price range.'
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'List of approved mentor profiles',
+  })
+  async findAll(@Query() queryDto: QueryMentorProfileDto) {
+    return this.mentorsService.findAll(queryDto);
+  }
+
   @Get('me/profile')
   @ApiOperation({ summary: 'Get my mentor profile' })
   @ApiResponse({
@@ -63,6 +81,19 @@ export class MentorsController {
     return this.mentorsService.getProfileByUserId(userId);
   }
 
+  @Get(':id')
+  @ApiOperation({ summary: 'Get mentor profile by ID' })
+  @ApiParam({ name: 'id', description: 'Mentor profile ID' })
+  @ApiResponse({
+    status: 200,
+    description: 'Profile retrieved successfully',
+    type: MentorProfileResponseDto,
+  })
+  @ApiResponse({ status: 404, description: 'Profile not found' })
+  async findOne(@Param('id') id: string): Promise<MentorProfileResponseDto> {
+    return this.mentorsService.findOne(id);
+  }
+
   @Put('me/profile')
   @ApiOperation({ summary: 'Update my mentor profile (only in draft status)' })
   @ApiResponse({
@@ -83,6 +114,43 @@ export class MentorsController {
     return this.mentorsService.updateProfile(userId, dto);
   }
 
+  @Patch(':id')
+  @ApiOperation({ 
+    summary: 'Update mentor profile by ID',
+    description: 'Mentors can only update their own profile and only in draft status'
+  })
+  @ApiParam({ name: 'id', description: 'Mentor profile ID' })
+  @ApiResponse({
+    status: 200,
+    description: 'Profile updated successfully',
+    type: MentorProfileResponseDto,
+  })
+  @ApiResponse({ status: 403, description: 'Forbidden - not your profile' })
+  @ApiResponse({ status: 404, description: 'Profile not found' })
+  async updateProfileById(
+    @Param('id') id: string,
+    @Request() req: any,
+    @Body() dto: UpdateMentorProfileDto,
+  ): Promise<MentorProfileResponseDto> {
+    const userId = req.user?.id || 'test-user-id';
+    return this.mentorsService.updateProfileById(id, userId, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ 
+    summary: 'Soft delete mentor profile',
+    description: 'Mentors can only delete their own profile'
+  })
+  @ApiParam({ name: 'id', description: 'Mentor profile ID' })
+  @ApiResponse({ status: 204, description: 'Profile deleted successfully' })
+  @ApiResponse({ status: 403, description: 'Forbidden - not your profile' })
+  @ApiResponse({ status: 404, description: 'Profile not found' })
+  async remove(@Param('id') id: string, @Request() req: any): Promise<void> {
+    const userId = req.user?.id || 'test-user-id';
+    await this.mentorsService.remove(id, userId);
+  }
+
   @Post('me/profile/submit')
   @HttpCode(HttpStatus.OK)
   @ApiOperation({
@@ -99,4 +167,4 @@ export class MentorsController {
     const userId = req.user?.id || 'test-user-id';
     return this.mentorsService.submitProfile(userId);
   }
-}
+}
\ No newline at end of file
diff --git a/apps/api/src/mentors-profile/mentors-profile.service.spec.ts b/apps/api/src/mentors-profile/mentors-profile.service.spec.ts
index 4aeeda6..867c1a8 100644
--- a/apps/api/src/mentors-profile/mentors-profile.service.spec.ts
+++ b/apps/api/src/mentors-profile/mentors-profile.service.spec.ts
@@ -1,334 +1,191 @@
-// src/mentors/mentors.service.spec.ts
 import { Test, TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import {
-  BadRequestException,
-  NotFoundException,
-  ForbiddenException,
-} from '@nestjs/common';
+import { MentorsController } from './mentors-profile.controller';
 import { MentorsService } from './mentors-profile.service';
-import {
-  MentorProfile,
-  MentorProfileStatus,
-} from './entities/mentors-profile.entity';
+import { MentorProfileStatus } from './entities/mentors-profile.entity';
 
-describe('MentorsService', () => {
+describe('MentorsController', () => {
+  let controller: MentorsController;
   let service: MentorsService;
-  let repository: Repository<MentorProfile>;
 
-  const mockRepository = {
-    create: jest.fn(),
-    save: jest.fn(),
+  const mockMentorsService = {
+    createProfile: jest.fn(),
+    findAll: jest.fn(),
     findOne: jest.fn(),
-    find: jest.fn(),
+    getProfileByUserId: jest.fn(),
+    updateProfile: jest.fn(),
+    updateProfileById: jest.fn(),
+    remove: jest.fn(),
+    submitProfile: jest.fn(),
+  };
+
+  const mockMentorProfile = {
+    id: '123e4567-e89b-12d3-a456-426614174000',
+    userId: '123e4567-e89b-12d3-a456-426614174001',
+    headline: 'Senior Full-Stack Developer',
+    rateMinor: 1000000, // 10,000 NGN in kobo
+    yearsExp: 5,
+    status: MentorProfileStatus.DRAFT,
+    createdAt: new Date(),
+    updatedAt: new Date(),
   };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
+      controllers: [MentorsController],
       providers: [
-        MentorsService,
         {
-          provide: getRepositoryToken(MentorProfile),
-          useValue: mockRepository,
+          provide: MentorsService,
+          useValue: mockMentorsService,
         },
       ],
     }).compile();
 
+    controller = module.get<MentorsController>(MentorsController);
     service = module.get<MentorsService>(MentorsService);
-    repository = module.get<Repository<MentorProfile>>(
-      getRepositoryToken(MentorProfile),
-    );
+  });
 
+  afterEach(() => {
     jest.clearAllMocks();
   });
 
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
   describe('createProfile', () => {
-    it('should create a mentor profile in draft status', async () => {
-      const userId = 'user-123';
-      const dto = {
-        headline: 'Senior Developer',
-        rateMinor: 1500000,
+    it('should create a mentor profile', async () => {
+      const createDto = {
+        headline: 'Senior Full-Stack Developer',
+        rateMinor: 1000000,
         yearsExp: 5,
       };
 
-      mockRepository.findOne.mockResolvedValue(null);
-      mockRepository.create.mockReturnValue({
-        userId,
-        ...dto,
-        status: MentorProfileStatus.DRAFT,
-      });
-      mockRepository.save.mockResolvedValue({
-        id: 'profile-123',
-        userId,
-        ...dto,
-        status: MentorProfileStatus.DRAFT,
-      });
-
-      const result = await service.createProfile(userId, dto);
-
-      expect(result.status).toBe(MentorProfileStatus.DRAFT);
-      expect(result.userId).toBe(userId);
-      expect(mockRepository.save).toHaveBeenCalled();
-    });
+      const req = { user: { id: '123e4567-e89b-12d3-a456-426614174001' } };
 
-    it('should throw BadRequestException if profile already exists', async () => {
-      const userId = 'user-123';
-      const dto = {
-        headline: 'Senior Developer',
-        rateMinor: 1500000,
-        yearsExp: 5,
-      };
+      mockMentorsService.createProfile.mockResolvedValue(mockMentorProfile);
 
-      mockRepository.findOne.mockResolvedValue({ id: 'existing-profile' });
+      const result = await controller.createProfile(req, createDto);
 
-      await expect(service.createProfile(userId, dto)).rejects.toThrow(
-        BadRequestException,
+      expect(result).toEqual(mockMentorProfile);
+      expect(mockMentorsService.createProfile).toHaveBeenCalledWith(
+        req.user.id,
+        createDto,
       );
     });
   });
 
-  describe('updateProfile', () => {
-    it('should update profile in draft status', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        headline: 'Old Headline',
-        rateMinor: 1000000,
-        yearsExp: 3,
-        status: MentorProfileStatus.DRAFT,
-      };
-
-      const updateDto = { headline: 'New Headline' };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({ ...profile, ...updateDto });
-
-      const result = await service.updateProfile(userId, updateDto);
-
-      expect(result.headline).toBe('New Headline');
-      expect(mockRepository.save).toHaveBeenCalled();
-    });
-
-    it('should throw BadRequestException when updating non-draft profile', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        status: MentorProfileStatus.SUBMITTED,
+  describe('findAll', () => {
+    it('should return paginated mentors with filters', async () => {
+      const queryDto = {
+        expertise: 'JavaScript',
+        minPrice: 5000,
+        maxPrice: 15000,
+        page: 1,
+        limit: 10,
       };
 
-      mockRepository.findOne.mockResolvedValue(profile);
-
-      await expect(
-        service.updateProfile(userId, { headline: 'New' }),
-      ).rejects.toThrow(BadRequestException);
-    });
-  });
-
-  describe('submitProfile', () => {
-    it('should transition from draft to submitted', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        status: MentorProfileStatus.DRAFT,
+      const paginatedResult = {
+        data: [mockMentorProfile],
+        total: 1,
+        page: 1,
+        limit: 10,
+        totalPages: 1,
       };
 
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.SUBMITTED,
-      });
+      mockMentorsService.findAll.mockResolvedValue(paginatedResult);
 
-      const result = await service.submitProfile(userId);
+      const result = await controller.findAll(queryDto);
 
-      expect(result.status).toBe(MentorProfileStatus.SUBMITTED);
+      expect(result).toEqual(paginatedResult);
+      expect(mockMentorsService.findAll).toHaveBeenCalledWith(queryDto);
     });
 
-    it('should throw BadRequestException when submitting non-draft profile', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        status: MentorProfileStatus.APPROVED,
-      };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-
-      await expect(service.submitProfile(userId)).rejects.toThrow(
-        BadRequestException,
-      );
-    });
-  });
+    it('should return all mentors without filters', async () => {
+      const queryDto = { page: 1, limit: 10 };
 
-  describe('approveProfile', () => {
-    it('should transition from submitted to approved', async () => {
-      const profileId = 'profile-123';
-      const profile = {
-        id: profileId,
-        userId: 'user-123',
-        status: MentorProfileStatus.SUBMITTED,
+      const paginatedResult = {
+        data: [mockMentorProfile],
+        total: 1,
+        page: 1,
+        limit: 10,
+        totalPages: 1,
       };
 
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.APPROVED,
-      });
+      mockMentorsService.findAll.mockResolvedValue(paginatedResult);
 
-      const result = await service.approveProfile(profileId);
+      const result = await controller.findAll(queryDto);
 
-      expect(result.status).toBe(MentorProfileStatus.APPROVED);
+      expect(result).toEqual(paginatedResult);
     });
+  });
 
-    it('should throw BadRequestException when approving non-submitted profile', async () => {
-      const profileId = 'profile-123';
-      const profile = {
-        id: profileId,
-        status: MentorProfileStatus.DRAFT,
-      };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-
-      await expect(service.approveProfile(profileId)).rejects.toThrow(
-        BadRequestException,
-      );
-    });
+  describe('findOne', () => {
+    it('should return a single mentor by id', async () => {
+      mockMentorsService.findOne.mockResolvedValue(mockMentorProfile);
 
-    it('should throw NotFoundException when profile does not exist', async () => {
-      mockRepository.findOne.mockResolvedValue(null);
+      const result = await controller.findOne(mockMentorProfile.id);
 
-      await expect(service.approveProfile('invalid-id')).rejects.toThrow(
-        NotFoundException,
+      expect(result).toEqual(mockMentorProfile);
+      expect(mockMentorsService.findOne).toHaveBeenCalledWith(
+        mockMentorProfile.id,
       );
     });
   });
 
-  describe('rejectProfile', () => {
-    it('should transition from submitted to rejected', async () => {
-      const profileId = 'profile-123';
-      const profile = {
-        id: profileId,
-        userId: 'user-123',
-        status: MentorProfileStatus.SUBMITTED,
-      };
+  describe('updateProfileById', () => {
+    it('should update a mentor profile', async () => {
+      const updateDto = { rateMinor: 1200000 };
+      const req = { user: { id: mockMentorProfile.userId } };
+      const updatedMentor = { ...mockMentorProfile, rateMinor: 1200000 };
 
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.REJECTED,
-      });
+      mockMentorsService.updateProfileById.mockResolvedValue(updatedMentor);
 
-      const result = await service.rejectProfile(
-        profileId,
-        'Incomplete information',
+      const result = await controller.updateProfileById(
+        mockMentorProfile.id,
+        req,
+        updateDto,
       );
 
-      expect(result.status).toBe(MentorProfileStatus.REJECTED);
-    });
-
-    it('should throw BadRequestException when rejecting non-submitted profile', async () => {
-      const profileId = 'profile-123';
-      const profile = {
-        id: profileId,
-        status: MentorProfileStatus.APPROVED,
-      };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-
-      await expect(service.rejectProfile(profileId)).rejects.toThrow(
-        BadRequestException,
+      expect(result).toEqual(updatedMentor);
+      expect(mockMentorsService.updateProfileById).toHaveBeenCalledWith(
+        mockMentorProfile.id,
+        req.user.id,
+        updateDto,
       );
     });
   });
 
-  describe('validateOwnership', () => {
-    it('should throw ForbiddenException when user tries to modify another user profile', () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId: 'different-user',
-      } as MentorProfile;
+  describe('remove', () => {
+    it('should soft delete a mentor profile', async () => {
+      const req = { user: { id: mockMentorProfile.userId } };
 
-      expect(() => service.validateOwnership(userId, profile)).toThrow(
-        ForbiddenException,
-      );
-    });
+      mockMentorsService.remove.mockResolvedValue(undefined);
 
-    it('should not throw when user modifies their own profile', () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId: 'user-123',
-      } as MentorProfile;
+      await controller.remove(mockMentorProfile.id, req);
 
-      expect(() => service.validateOwnership(userId, profile)).not.toThrow();
+      expect(mockMentorsService.remove).toHaveBeenCalledWith(
+        mockMentorProfile.id,
+        req.user.id,
+      );
     });
   });
 
-  describe('status transitions', () => {
-    it('should allow draft → submitted transition', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        status: MentorProfileStatus.DRAFT,
-      };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.SUBMITTED,
-      });
-
-      await expect(service.submitProfile(userId)).resolves.toBeDefined();
-    });
-
-    it('should allow submitted → approved transition', async () => {
-      const profile = {
-        id: 'profile-123',
-        status: MentorProfileStatus.SUBMITTED,
-      };
-
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.APPROVED,
-      });
-
-      await expect(service.approveProfile(profile.id)).resolves.toBeDefined();
-    });
-
-    it('should allow submitted → rejected transition', async () => {
-      const profile = {
-        id: 'profile-123',
+  describe('submitProfile', () => {
+    it('should submit a profile for review', async () => {
+      const req = { user: { id: mockMentorProfile.userId } };
+      const submittedProfile = {
+        ...mockMentorProfile,
         status: MentorProfileStatus.SUBMITTED,
       };
 
-      mockRepository.findOne.mockResolvedValue(profile);
-      mockRepository.save.mockResolvedValue({
-        ...profile,
-        status: MentorProfileStatus.REJECTED,
-      });
-
-      await expect(service.rejectProfile(profile.id)).resolves.toBeDefined();
-    });
-
-    it('should not allow approved → submitted transition', async () => {
-      const userId = 'user-123';
-      const profile = {
-        id: 'profile-123',
-        userId,
-        status: MentorProfileStatus.APPROVED,
-      };
+      mockMentorsService.submitProfile.mockResolvedValue(submittedProfile);
 
-      mockRepository.findOne.mockResolvedValue(profile);
+      const result = await controller.submitProfile(req);
 
-      await expect(service.submitProfile(userId)).rejects.toThrow(
-        BadRequestException,
+      expect(result).toEqual(submittedProfile);
+      expect(mockMentorsService.submitProfile).toHaveBeenCalledWith(
+        req.user.id,
       );
     });
   });
-});
+});
\ No newline at end of file
diff --git a/apps/api/src/mentors-profile/mentors-profile.service.ts b/apps/api/src/mentors-profile/mentors-profile.service.ts
index 3f12d7b..d9be04f 100644
--- a/apps/api/src/mentors-profile/mentors-profile.service.ts
+++ b/apps/api/src/mentors-profile/mentors-profile.service.ts
@@ -1,4 +1,3 @@
-// src/mentors/mentors.service.ts
 import {
   Injectable,
   NotFoundException,
@@ -14,12 +13,12 @@ import {
 } from './entities/mentors-profile.entity';
 import { CreateMentorProfileDto } from './dto/create-mentors-profile.dto';
 import { UpdateMentorProfileDto } from './dto/update-mentors-profile.dto';
+import { QueryMentorProfileDto } from './dto/query-mentors-profile.dto';
 
 @Injectable()
 export class MentorsService {
   private readonly logger = new Logger(MentorsService.name);
 
-  // Allowed status transitions
   private readonly allowedTransitions: Record<
     MentorProfileStatus,
     MentorProfileStatus[]
@@ -42,7 +41,6 @@ export class MentorsService {
     userId: string,
     dto: CreateMentorProfileDto,
   ): Promise<MentorProfile> {
-    // Check if profile already exists
     const existing = await this.mentorProfileRepository.findOne({
       where: { userId },
     });
@@ -64,6 +62,72 @@ export class MentorsService {
     return saved;
   }
 
+  async findAll(queryDto: QueryMentorProfileDto) {
+    const { expertise, minPrice, maxPrice, page = 1, limit = 10 } = queryDto;
+    const skip = (page - 1) * limit;
+
+    const queryBuilder = this.mentorProfileRepository
+      .createQueryBuilder('mentor_profile')
+      .leftJoinAndSelect('mentor_profile.user', 'user')
+      .where('mentor_profile.status = :status', { status: MentorProfileStatus.APPROVED });
+
+    // Filter by expertise (search in headline)
+    if (expertise) {
+      queryBuilder.andWhere(
+        'LOWER(mentor_profile.headline) LIKE LOWER(:expertise)',
+        { expertise: `%${expertise}%` }
+      );
+    }
+
+    // Filter by price range (convert from NGN to kobo for comparison)
+    if (minPrice !== undefined && maxPrice !== undefined) {
+      const minPriceKobo = minPrice * 100;
+      const maxPriceKobo = maxPrice * 100;
+      queryBuilder.andWhere(
+        'mentor_profile.rateMinor BETWEEN :minPrice AND :maxPrice',
+        { minPrice: minPriceKobo, maxPrice: maxPriceKobo }
+      );
+    } else if (minPrice !== undefined) {
+      const minPriceKobo = minPrice * 100;
+      queryBuilder.andWhere('mentor_profile.rateMinor >= :minPrice', { 
+        minPrice: minPriceKobo 
+      });
+    } else if (maxPrice !== undefined) {
+      const maxPriceKobo = maxPrice * 100;
+      queryBuilder.andWhere('mentor_profile.rateMinor <= :maxPrice', { 
+        maxPrice: maxPriceKobo 
+      });
+    }
+
+    queryBuilder.orderBy('mentor_profile.createdAt', 'DESC');
+
+    const [data, total] = await queryBuilder
+      .skip(skip)
+      .take(limit)
+      .getManyAndCount();
+
+    return {
+      data,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+    };
+  }
+
+  async findOne(id: string): Promise<MentorProfile> {
+    const mentorProfile = await this.mentorProfileRepository.findOne({
+      where: { id },
+      relations: ['user'],
+    });
+
+    if (!mentorProfile) {
+      throw new NotFoundException(`Mentor profile with ID ${id} not found`);
+    }
+
+    return mentorProfile;
+  }
+
   async getProfileByUserId(userId: string): Promise<MentorProfile> {
     const profile = await this.mentorProfileRepository.findOne({
       where: { userId },
@@ -83,7 +147,6 @@ export class MentorsService {
   ): Promise<MentorProfile> {
     const profile = await this.getProfileByUserId(userId);
 
-    // Only allow updates in draft status
     if (profile.status !== MentorProfileStatus.DRAFT) {
       throw new BadRequestException(
         `Cannot update profile in ${profile.status} status. Profile must be in draft status.`,
@@ -97,6 +160,32 @@ export class MentorsService {
     return updated;
   }
 
+  async updateProfileById(
+    id: string,
+    userId: string,
+    dto: UpdateMentorProfileDto,
+  ): Promise<MentorProfile> {
+    const profile = await this.findOne(id);
+    this.validateOwnership(userId, profile);
+
+    if (profile.status !== MentorProfileStatus.DRAFT) {
+      throw new BadRequestException(
+        `Cannot update profile in ${profile.status} status. Profile must be in draft status.`,
+      );
+    }
+
+    Object.assign(profile, dto);
+    return await this.mentorProfileRepository.save(profile);
+  }
+
+  async remove(id: string, userId: string): Promise<void> {
+    const profile = await this.findOne(id);
+    this.validateOwnership(userId, profile);
+
+    await this.mentorProfileRepository.softDelete(id);
+    this.logger.log(`Soft deleted mentor profile ${id}`);
+  }
+
   async submitProfile(userId: string): Promise<MentorProfile> {
     const profile = await this.getProfileByUserId(userId);
 
@@ -179,4 +268,4 @@ export class MentorsService {
       );
     }
   }
-}
+}
\ No newline at end of file