diff --git a/api/CourseRegistration.API/Controllers/InstructorRatingsController.cs b/api/CourseRegistration.API/Controllers/InstructorRatingsController.cs
new file mode 100644
index 0000000..efb8734
--- /dev/null
+++ b/api/CourseRegistration.API/Controllers/InstructorRatingsController.cs
@@ -0,0 +1,207 @@
+using Microsoft.AspNetCore.Mvc;
+using CourseRegistration.Application.DTOs;
+using CourseRegistration.Application.Interfaces;
+
+namespace CourseRegistration.API.Controllers;
+
+/// <summary>
+/// Controller for instructor rating operations
+/// </summary>
+[ApiController]
+[Route("api/[controller]")]
+[Produces("application/json")]
+public class InstructorRatingsController : ControllerBase
+{
+    private readonly IInstructorRatingService _ratingService;
+    private readonly ILogger<InstructorRatingsController> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the InstructorRatingsController
+    /// </summary>
+    public InstructorRatingsController(IInstructorRatingService ratingService, ILogger<InstructorRatingsController> logger)
+    {
+        _ratingService = ratingService ?? throw new ArgumentNullException(nameof(ratingService));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Creates a new instructor rating
+    /// </summary>
+    /// <param name="createRatingDto">Rating creation details</param>
+    /// <returns>Created rating</returns>
+    [HttpPost]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> CreateRating([FromBody] CreateInstructorRatingDto createRatingDto)
+    {
+        _logger.LogInformation("Creating new rating for course {CourseId} by student {StudentId}", 
+            createRatingDto.CourseId, createRatingDto.StudentId);
+
+        try
+        {
+            var rating = await _ratingService.CreateRatingAsync(createRatingDto);
+            
+            return CreatedAtAction(
+                nameof(GetRating),
+                new { id = rating.RatingId },
+                ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating created successfully"));
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning("Failed to create rating: {Message}", ex.Message);
+            return BadRequest(ApiResponseDto<InstructorRatingDto>.ErrorResponse(ex.Message));
+        }
+    }
+
+    /// <summary>
+    /// Gets a rating by ID
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <returns>Rating details</returns>
+    [HttpGet("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> GetRating(Guid id)
+    {
+        _logger.LogInformation("Getting rating with ID: {RatingId}", id);
+        
+        var rating = await _ratingService.GetRatingByIdAsync(id);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("course/{courseId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByCourse(Guid courseId)
+    {
+        _logger.LogInformation("Getting ratings for course: {CourseId}", courseId);
+        
+        var ratings = await _ratingService.GetRatingsByCourseIdAsync(courseId);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    /// <param name="studentId">Student ID</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("student/{studentId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByStudent(Guid studentId)
+    {
+        _logger.LogInformation("Getting ratings by student: {StudentId}", studentId);
+        
+        var ratings = await _ratingService.GetRatingsByStudentIdAsync(studentId);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor
+    /// </summary>
+    /// <param name="instructorName">Instructor name</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("instructor/{instructorName}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByInstructor(string instructorName)
+    {
+        _logger.LogInformation("Getting ratings for instructor: {InstructorName}", instructorName);
+        
+        var ratings = await _ratingService.GetRatingsByInstructorNameAsync(instructorName);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets rating statistics for an instructor
+    /// </summary>
+    /// <param name="instructorName">Instructor name</param>
+    /// <returns>Rating statistics</returns>
+    [HttpGet("instructor/{instructorName}/stats")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingStatsDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingStatsDto>>> GetInstructorStats(string instructorName)
+    {
+        _logger.LogInformation("Getting stats for instructor: {InstructorName}", instructorName);
+        
+        var stats = await _ratingService.GetInstructorStatsAsync(instructorName);
+        if (stats == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingStatsDto>.ErrorResponse("No ratings found for this instructor"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingStatsDto>.SuccessResponse(stats, "Statistics retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets a rating by student and course
+    /// </summary>
+    /// <param name="studentId">Student ID</param>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>Rating details</returns>
+    [HttpGet("student/{studentId:guid}/course/{courseId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> GetRatingByStudentAndCourse(Guid studentId, Guid courseId)
+    {
+        _logger.LogInformation("Getting rating for student {StudentId} and course {CourseId}", studentId, courseId);
+        
+        var rating = await _ratingService.GetRatingByStudentAndCourseAsync(studentId, courseId);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Updates an existing rating
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <param name="updateRatingDto">Rating update details</param>
+    /// <returns>Updated rating</returns>
+    [HttpPut("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> UpdateRating(Guid id, [FromBody] UpdateInstructorRatingDto updateRatingDto)
+    {
+        _logger.LogInformation("Updating rating with ID: {RatingId}", id);
+        
+        var rating = await _ratingService.UpdateRatingAsync(id, updateRatingDto);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating updated successfully"));
+    }
+
+    /// <summary>
+    /// Deletes a rating
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <returns>Success status</returns>
+    [HttpDelete("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<object>>> DeleteRating(Guid id)
+    {
+        _logger.LogInformation("Deleting rating with ID: {RatingId}", id);
+        
+        var success = await _ratingService.DeleteRatingAsync(id);
+        if (!success)
+        {
+            return NotFound(ApiResponseDto<object>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<object>.SuccessResponse(null, "Rating deleted successfully"));
+    }
+}
diff --git a/api/CourseRegistration.API/CourseRegistration.API.csproj b/api/CourseRegistration.API/CourseRegistration.API.csproj
index 1653847..4ead178 100644
--- a/api/CourseRegistration.API/CourseRegistration.API.csproj
+++ b/api/CourseRegistration.API/CourseRegistration.API.csproj
@@ -8,6 +8,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.11" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.11">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="8.0.11" />
     <PackageReference Include="Serilog.AspNetCore" Version="8.0.2" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.9.0" />
diff --git a/api/CourseRegistration.API/Program.cs b/api/CourseRegistration.API/Program.cs
index e7e52e4..c0be55d 100644
--- a/api/CourseRegistration.API/Program.cs
+++ b/api/CourseRegistration.API/Program.cs
@@ -60,12 +60,14 @@
 builder.Services.AddScoped<IStudentRepository, StudentRepository>();
 builder.Services.AddScoped<ICourseRepository, CourseRepository>();
 builder.Services.AddScoped<IRegistrationRepository, RegistrationRepository>();
+builder.Services.AddScoped<IInstructorRatingRepository, InstructorRatingRepository>();
 builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 
 // Register services
 builder.Services.AddScoped<IStudentService, StudentService>();
 builder.Services.AddScoped<ICourseService, CourseService>();
 builder.Services.AddScoped<IRegistrationService, RegistrationService>();
+builder.Services.AddScoped<IInstructorRatingService, InstructorRatingService>();
 
 // Register authorization services
 builder.Services.AddScoped<AuthorizationService>();
diff --git a/api/CourseRegistration.Application/DTOs/InstructorRatingDtos.cs b/api/CourseRegistration.Application/DTOs/InstructorRatingDtos.cs
new file mode 100644
index 0000000..749010e
--- /dev/null
+++ b/api/CourseRegistration.Application/DTOs/InstructorRatingDtos.cs
@@ -0,0 +1,160 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace CourseRegistration.Application.DTOs;
+
+/// <summary>
+/// DTO for creating a new instructor rating
+/// </summary>
+public class CreateInstructorRatingDto
+{
+    /// <summary>
+    /// Course ID for which the instructor is being rated
+    /// </summary>
+    [Required]
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Student ID who is submitting the rating
+    /// </summary>
+    [Required]
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    [Required]
+    [Range(1, 5, ErrorMessage = "Rating must be between 1 and 5")]
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    [MaxLength(1000, ErrorMessage = "Comment cannot exceed 1000 characters")]
+    public string? Comment { get; set; }
+}
+
+/// <summary>
+/// DTO for updating an existing instructor rating
+/// </summary>
+public class UpdateInstructorRatingDto
+{
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    [Required]
+    [Range(1, 5, ErrorMessage = "Rating must be between 1 and 5")]
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    [MaxLength(1000, ErrorMessage = "Comment cannot exceed 1000 characters")]
+    public string? Comment { get; set; }
+}
+
+/// <summary>
+/// DTO for returning instructor rating details
+/// </summary>
+public class InstructorRatingDto
+{
+    /// <summary>
+    /// Unique identifier for the rating
+    /// </summary>
+    public Guid RatingId { get; set; }
+
+    /// <summary>
+    /// Course ID
+    /// </summary>
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Course name
+    /// </summary>
+    public string CourseName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Instructor name
+    /// </summary>
+    public string InstructorName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Student ID who submitted the rating
+    /// </summary>
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Student name
+    /// </summary>
+    public string StudentName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    public string? Comment { get; set; }
+
+    /// <summary>
+    /// Date when the rating was created
+    /// </summary>
+    public DateTime CreatedAt { get; set; }
+
+    /// <summary>
+    /// Date when the rating was last updated
+    /// </summary>
+    public DateTime UpdatedAt { get; set; }
+}
+
+/// <summary>
+/// DTO for instructor rating statistics
+/// </summary>
+public class InstructorRatingStatsDto
+{
+    /// <summary>
+    /// Instructor name
+    /// </summary>
+    public string InstructorName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Average rating
+    /// </summary>
+    public double AverageRating { get; set; }
+
+    /// <summary>
+    /// Total number of ratings
+    /// </summary>
+    public int TotalRatings { get; set; }
+
+    /// <summary>
+    /// Number of 5-star ratings
+    /// </summary>
+    public int FiveStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 4-star ratings
+    /// </summary>
+    public int FourStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 3-star ratings
+    /// </summary>
+    public int ThreeStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 2-star ratings
+    /// </summary>
+    public int TwoStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 1-star ratings
+    /// </summary>
+    public int OneStarCount { get; set; }
+
+    /// <summary>
+    /// List of courses taught by this instructor
+    /// </summary>
+    public List<Guid> CourseIds { get; set; } = new();
+}
diff --git a/api/CourseRegistration.Application/Interfaces/IInstructorRatingService.cs b/api/CourseRegistration.Application/Interfaces/IInstructorRatingService.cs
new file mode 100644
index 0000000..089f84c
--- /dev/null
+++ b/api/CourseRegistration.Application/Interfaces/IInstructorRatingService.cs
@@ -0,0 +1,54 @@
+using CourseRegistration.Application.DTOs;
+
+namespace CourseRegistration.Application.Interfaces;
+
+/// <summary>
+/// Service interface for instructor rating operations
+/// </summary>
+public interface IInstructorRatingService
+{
+    /// <summary>
+    /// Creates a new instructor rating
+    /// </summary>
+    Task<InstructorRatingDto> CreateRatingAsync(CreateInstructorRatingDto createRatingDto);
+
+    /// <summary>
+    /// Gets a rating by ID
+    /// </summary>
+    Task<InstructorRatingDto?> GetRatingByIdAsync(Guid ratingId);
+
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    Task<IEnumerable<InstructorRatingDto>> GetRatingsByCourseIdAsync(Guid courseId);
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    Task<IEnumerable<InstructorRatingDto>> GetRatingsByStudentIdAsync(Guid studentId);
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor
+    /// </summary>
+    Task<IEnumerable<InstructorRatingDto>> GetRatingsByInstructorNameAsync(string instructorName);
+
+    /// <summary>
+    /// Gets rating statistics for an instructor
+    /// </summary>
+    Task<InstructorRatingStatsDto?> GetInstructorStatsAsync(string instructorName);
+
+    /// <summary>
+    /// Updates an existing rating
+    /// </summary>
+    Task<InstructorRatingDto?> UpdateRatingAsync(Guid ratingId, UpdateInstructorRatingDto updateRatingDto);
+
+    /// <summary>
+    /// Deletes a rating
+    /// </summary>
+    Task<bool> DeleteRatingAsync(Guid ratingId);
+
+    /// <summary>
+    /// Gets a rating by student and course
+    /// </summary>
+    Task<InstructorRatingDto?> GetRatingByStudentAndCourseAsync(Guid studentId, Guid courseId);
+}
diff --git a/api/CourseRegistration.Application/Mappings/MappingProfile.cs b/api/CourseRegistration.Application/Mappings/MappingProfile.cs
index 10be3ee..bdf158a 100644
--- a/api/CourseRegistration.Application/Mappings/MappingProfile.cs
+++ b/api/CourseRegistration.Application/Mappings/MappingProfile.cs
@@ -69,5 +69,27 @@ public MappingProfile()
             .ForMember(dest => dest.RegistrationDate, opt => opt.Ignore())
             .ForMember(dest => dest.Student, opt => opt.Ignore())
             .ForMember(dest => dest.Course, opt => opt.Ignore());
+
+        // InstructorRating mappings
+        CreateMap<InstructorRating, InstructorRatingDto>()
+            .ForMember(dest => dest.CourseName, opt => opt.MapFrom(src => src.Course.CourseName))
+            .ForMember(dest => dest.InstructorName, opt => opt.MapFrom(src => src.Course.InstructorName))
+            .ForMember(dest => dest.StudentName, opt => opt.MapFrom(src => src.Student.FullName));
+
+        CreateMap<CreateInstructorRatingDto, InstructorRating>()
+            .ForMember(dest => dest.RatingId, opt => opt.Ignore())
+            .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.Course, opt => opt.Ignore())
+            .ForMember(dest => dest.Student, opt => opt.Ignore());
+
+        CreateMap<UpdateInstructorRatingDto, InstructorRating>()
+            .ForMember(dest => dest.RatingId, opt => opt.Ignore())
+            .ForMember(dest => dest.CourseId, opt => opt.Ignore())
+            .ForMember(dest => dest.StudentId, opt => opt.Ignore())
+            .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.Course, opt => opt.Ignore())
+            .ForMember(dest => dest.Student, opt => opt.Ignore());
     }
 }
\ No newline at end of file
diff --git a/api/CourseRegistration.Application/Services/InstructorRatingService.cs b/api/CourseRegistration.Application/Services/InstructorRatingService.cs
new file mode 100644
index 0000000..7b983ab
--- /dev/null
+++ b/api/CourseRegistration.Application/Services/InstructorRatingService.cs
@@ -0,0 +1,180 @@
+using AutoMapper;
+using CourseRegistration.Application.DTOs;
+using CourseRegistration.Application.Interfaces;
+using CourseRegistration.Domain.Entities;
+using CourseRegistration.Domain.Interfaces;
+
+namespace CourseRegistration.Application.Services;
+
+/// <summary>
+/// Service implementation for instructor rating operations
+/// </summary>
+public class InstructorRatingService : IInstructorRatingService
+{
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// Initializes a new instance of the InstructorRatingService
+    /// </summary>
+    public InstructorRatingService(IUnitOfWork unitOfWork, IMapper mapper)
+    {
+        _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
+        _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
+    }
+
+    /// <summary>
+    /// Creates a new instructor rating
+    /// </summary>
+    public async Task<InstructorRatingDto> CreateRatingAsync(CreateInstructorRatingDto createRatingDto)
+    {
+        // Validate that the course exists
+        var course = await _unitOfWork.Courses.GetByIdAsync(createRatingDto.CourseId);
+        if (course == null)
+        {
+            throw new InvalidOperationException("Course not found.");
+        }
+
+        // Validate that the student exists
+        var student = await _unitOfWork.Students.GetByIdAsync(createRatingDto.StudentId);
+        if (student == null)
+        {
+            throw new InvalidOperationException("Student not found.");
+        }
+
+        // Check if student has already rated this course
+        var existingRating = await _unitOfWork.InstructorRatings
+            .GetByStudentAndCourseAsync(createRatingDto.StudentId, createRatingDto.CourseId);
+        
+        if (existingRating != null)
+        {
+            throw new InvalidOperationException("Student has already rated this course. Use update instead.");
+        }
+
+        // Validate that student is enrolled in the course
+        var isEnrolled = await _unitOfWork.Registrations
+            .IsStudentRegisteredForCourseAsync(createRatingDto.StudentId, createRatingDto.CourseId);
+        
+        if (!isEnrolled)
+        {
+            throw new InvalidOperationException("Student must be enrolled in the course to submit a rating.");
+        }
+
+        var rating = _mapper.Map<InstructorRating>(createRatingDto);
+        await _unitOfWork.InstructorRatings.AddAsync(rating);
+        await _unitOfWork.SaveChangesAsync();
+
+        // Retrieve with details for response
+        var ratingWithDetails = await _unitOfWork.InstructorRatings.GetWithDetailsAsync(rating.RatingId);
+        return _mapper.Map<InstructorRatingDto>(ratingWithDetails);
+    }
+
+    /// <summary>
+    /// Gets a rating by ID
+    /// </summary>
+    public async Task<InstructorRatingDto?> GetRatingByIdAsync(Guid ratingId)
+    {
+        var rating = await _unitOfWork.InstructorRatings.GetWithDetailsAsync(ratingId);
+        return rating != null ? _mapper.Map<InstructorRatingDto>(rating) : null;
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    public async Task<IEnumerable<InstructorRatingDto>> GetRatingsByCourseIdAsync(Guid courseId)
+    {
+        var ratings = await _unitOfWork.InstructorRatings.GetByCourseIdAsync(courseId);
+        return _mapper.Map<IEnumerable<InstructorRatingDto>>(ratings);
+    }
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    public async Task<IEnumerable<InstructorRatingDto>> GetRatingsByStudentIdAsync(Guid studentId)
+    {
+        var ratings = await _unitOfWork.InstructorRatings.GetByStudentIdAsync(studentId);
+        return _mapper.Map<IEnumerable<InstructorRatingDto>>(ratings);
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor
+    /// </summary>
+    public async Task<IEnumerable<InstructorRatingDto>> GetRatingsByInstructorNameAsync(string instructorName)
+    {
+        var ratings = await _unitOfWork.InstructorRatings.GetByInstructorNameAsync(instructorName);
+        return _mapper.Map<IEnumerable<InstructorRatingDto>>(ratings);
+    }
+
+    /// <summary>
+    /// Gets rating statistics for an instructor
+    /// </summary>
+    public async Task<InstructorRatingStatsDto?> GetInstructorStatsAsync(string instructorName)
+    {
+        var ratings = await _unitOfWork.InstructorRatings.GetByInstructorNameAsync(instructorName);
+        var ratingsList = ratings.ToList();
+
+        if (!ratingsList.Any())
+        {
+            return null;
+        }
+
+        var courses = await _unitOfWork.Courses.GetCoursesByInstructorAsync(instructorName);
+        
+        return new InstructorRatingStatsDto
+        {
+            InstructorName = instructorName,
+            AverageRating = ratingsList.Average(r => r.Rating),
+            TotalRatings = ratingsList.Count,
+            FiveStarCount = ratingsList.Count(r => r.Rating == 5),
+            FourStarCount = ratingsList.Count(r => r.Rating == 4),
+            ThreeStarCount = ratingsList.Count(r => r.Rating == 3),
+            TwoStarCount = ratingsList.Count(r => r.Rating == 2),
+            OneStarCount = ratingsList.Count(r => r.Rating == 1),
+            CourseIds = courses.Select(c => c.CourseId).ToList()
+        };
+    }
+
+    /// <summary>
+    /// Updates an existing rating
+    /// </summary>
+    public async Task<InstructorRatingDto?> UpdateRatingAsync(Guid ratingId, UpdateInstructorRatingDto updateRatingDto)
+    {
+        var existingRating = await _unitOfWork.InstructorRatings.GetByIdAsync(ratingId);
+        if (existingRating == null)
+        {
+            return null;
+        }
+
+        _mapper.Map(updateRatingDto, existingRating);
+        _unitOfWork.InstructorRatings.Update(existingRating);
+        await _unitOfWork.SaveChangesAsync();
+
+        var ratingWithDetails = await _unitOfWork.InstructorRatings.GetWithDetailsAsync(ratingId);
+        return _mapper.Map<InstructorRatingDto>(ratingWithDetails);
+    }
+
+    /// <summary>
+    /// Deletes a rating
+    /// </summary>
+    public async Task<bool> DeleteRatingAsync(Guid ratingId)
+    {
+        var rating = await _unitOfWork.InstructorRatings.GetByIdAsync(ratingId);
+        if (rating == null)
+        {
+            return false;
+        }
+
+        _unitOfWork.InstructorRatings.Remove(rating);
+        await _unitOfWork.SaveChangesAsync();
+        return true;
+    }
+
+    /// <summary>
+    /// Gets a rating by student and course
+    /// </summary>
+    public async Task<InstructorRatingDto?> GetRatingByStudentAndCourseAsync(Guid studentId, Guid courseId)
+    {
+        var rating = await _unitOfWork.InstructorRatings.GetByStudentAndCourseAsync(studentId, courseId);
+        return rating != null ? _mapper.Map<InstructorRatingDto>(rating) : null;
+    }
+}
diff --git a/api/CourseRegistration.Domain/Entities/Course.cs b/api/CourseRegistration.Domain/Entities/Course.cs
index dc3f941..d7571bd 100644
--- a/api/CourseRegistration.Domain/Entities/Course.cs
+++ b/api/CourseRegistration.Domain/Entities/Course.cs
@@ -73,6 +73,11 @@ public class Course
     /// </summary>
     public virtual ICollection<Registration> Registrations { get; set; } = new List<Registration>();
 
+    /// <summary>
+    /// Navigation property for instructor ratings
+    /// </summary>
+    public virtual ICollection<InstructorRating> InstructorRatings { get; set; } = new List<InstructorRating>();
+
     /// <summary>
     /// Computed property for current enrollment count
     /// </summary>
diff --git a/api/CourseRegistration.Domain/Entities/InstructorRating.cs b/api/CourseRegistration.Domain/Entities/InstructorRating.cs
new file mode 100644
index 0000000..e1ed6cb
--- /dev/null
+++ b/api/CourseRegistration.Domain/Entities/InstructorRating.cs
@@ -0,0 +1,63 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace CourseRegistration.Domain.Entities;
+
+/// <summary>
+/// Represents a student's rating and review of an instructor for a specific course
+/// </summary>
+public class InstructorRating
+{
+    /// <summary>
+    /// Unique identifier for the rating
+    /// </summary>
+    [Key]
+    public Guid RatingId { get; set; } = Guid.NewGuid();
+
+    /// <summary>
+    /// Foreign key to the course
+    /// </summary>
+    [Required]
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Foreign key to the student who submitted the rating
+    /// </summary>
+    [Required]
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    [Required]
+    [Range(1, 5)]
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    [MaxLength(1000)]
+    public string? Comment { get; set; }
+
+    /// <summary>
+    /// Date when the rating was created
+    /// </summary>
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Date when the rating was last updated
+    /// </summary>
+    public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Navigation property to the course
+    /// </summary>
+    [ForeignKey(nameof(CourseId))]
+    public virtual Course Course { get; set; } = null!;
+
+    /// <summary>
+    /// Navigation property to the student
+    /// </summary>
+    [ForeignKey(nameof(StudentId))]
+    public virtual Student Student { get; set; } = null!;
+}
diff --git a/api/CourseRegistration.Domain/Entities/Student.cs b/api/CourseRegistration.Domain/Entities/Student.cs
index ee4a5b1..ffa5cee 100644
--- a/api/CourseRegistration.Domain/Entities/Student.cs
+++ b/api/CourseRegistration.Domain/Entities/Student.cs
@@ -69,6 +69,11 @@ public class Student
     /// </summary>
     public virtual ICollection<Registration> Registrations { get; set; } = new List<Registration>();
 
+    /// <summary>
+    /// Navigation property for student's instructor ratings
+    /// </summary>
+    public virtual ICollection<InstructorRating> InstructorRatings { get; set; } = new List<InstructorRating>();
+
     /// <summary>
     /// Computed property for student's full name
     /// </summary>
diff --git a/api/CourseRegistration.Domain/Interfaces/IInstructorRatingRepository.cs b/api/CourseRegistration.Domain/Interfaces/IInstructorRatingRepository.cs
new file mode 100644
index 0000000..d3ca9b4
--- /dev/null
+++ b/api/CourseRegistration.Domain/Interfaces/IInstructorRatingRepository.cs
@@ -0,0 +1,44 @@
+using CourseRegistration.Domain.Entities;
+
+namespace CourseRegistration.Domain.Interfaces;
+
+/// <summary>
+/// InstructorRating repository interface with specific operations
+/// </summary>
+public interface IInstructorRatingRepository : IRepository<InstructorRating>
+{
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    Task<IEnumerable<InstructorRating>> GetByCourseIdAsync(Guid courseId);
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    Task<IEnumerable<InstructorRating>> GetByStudentIdAsync(Guid studentId);
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor across all courses
+    /// </summary>
+    Task<IEnumerable<InstructorRating>> GetByInstructorNameAsync(string instructorName);
+
+    /// <summary>
+    /// Gets a specific rating by student and course
+    /// </summary>
+    Task<InstructorRating?> GetByStudentAndCourseAsync(Guid studentId, Guid courseId);
+
+    /// <summary>
+    /// Checks if a student has already rated a course
+    /// </summary>
+    Task<bool> HasStudentRatedCourseAsync(Guid studentId, Guid courseId);
+
+    /// <summary>
+    /// Gets average rating for an instructor
+    /// </summary>
+    Task<double?> GetAverageRatingForInstructorAsync(string instructorName);
+
+    /// <summary>
+    /// Gets rating with student and course details
+    /// </summary>
+    Task<InstructorRating?> GetWithDetailsAsync(Guid ratingId);
+}
diff --git a/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs b/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs
index c56d8f4..72b409a 100644
--- a/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs
+++ b/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs
@@ -20,6 +20,11 @@ public interface IUnitOfWork : IDisposable
     /// </summary>
     IRegistrationRepository Registrations { get; }
 
+    /// <summary>
+    /// InstructorRating repository
+    /// </summary>
+    IInstructorRatingRepository InstructorRatings { get; }
+
     /// <summary>
     /// Saves all changes made in this unit of work asynchronously
     /// </summary>
diff --git a/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs b/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs
index 7491da8..afa0e65 100644
--- a/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs
+++ b/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs
@@ -32,6 +32,11 @@ public CourseRegistrationDbContext(DbContextOptions<CourseRegistrationDbContext>
     /// </summary>
     public DbSet<Registration> Registrations { get; set; } = null!;
 
+    /// <summary>
+    /// InstructorRatings DbSet
+    /// </summary>
+    public DbSet<InstructorRating> InstructorRatings { get; set; } = null!;
+
     /// <summary>
     /// Configures the model relationships and constraints
     /// </summary>
@@ -108,6 +113,33 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                   .HasForeignKey(r => r.CourseId)
                   .OnDelete(DeleteBehavior.Cascade);
         });
+
+        // Configure InstructorRating entity
+        modelBuilder.Entity<InstructorRating>(entity =>
+        {
+            entity.HasKey(ir => ir.RatingId);
+            entity.Property(ir => ir.CourseId).IsRequired();
+            entity.Property(ir => ir.StudentId).IsRequired();
+            entity.Property(ir => ir.Rating).IsRequired();
+            entity.Property(ir => ir.Comment).HasMaxLength(1000);
+            entity.Property(ir => ir.CreatedAt).IsRequired();
+            entity.Property(ir => ir.UpdatedAt).IsRequired();
+
+            // Create unique constraint to prevent duplicate ratings per student per course
+            entity.HasIndex(ir => new { ir.StudentId, ir.CourseId })
+                  .IsUnique();
+
+            // Configure relationships
+            entity.HasOne(ir => ir.Student)
+                  .WithMany(s => s.InstructorRatings)
+                  .HasForeignKey(ir => ir.StudentId)
+                  .OnDelete(DeleteBehavior.Cascade);
+
+            entity.HasOne(ir => ir.Course)
+                  .WithMany(c => c.InstructorRatings)
+                  .HasForeignKey(ir => ir.CourseId)
+                  .OnDelete(DeleteBehavior.Cascade);
+        });
     }
 
     /// <summary>
@@ -156,6 +188,14 @@ private void UpdateTimestamps()
                 }
                 course.UpdatedAt = currentTime;
             }
+            else if (entry.Entity is InstructorRating rating)
+            {
+                if (entry.State == EntityState.Added)
+                {
+                    rating.CreatedAt = currentTime;
+                }
+                rating.UpdatedAt = currentTime;
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContextFactory.cs b/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContextFactory.cs
new file mode 100644
index 0000000..0269dca
--- /dev/null
+++ b/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContextFactory.cs
@@ -0,0 +1,20 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace CourseRegistration.Infrastructure.Data;
+
+/// <summary>
+/// Design-time factory for CourseRegistrationDbContext to enable migrations
+/// </summary>
+public class CourseRegistrationDbContextFactory : IDesignTimeDbContextFactory<CourseRegistrationDbContext>
+{
+    public CourseRegistrationDbContext CreateDbContext(string[] args)
+    {
+        var optionsBuilder = new DbContextOptionsBuilder<CourseRegistrationDbContext>();
+        
+        // Use in-memory database for design-time operations
+        optionsBuilder.UseInMemoryDatabase("CourseRegistrationDb");
+        
+        return new CourseRegistrationDbContext(optionsBuilder.Options);
+    }
+}
diff --git a/api/CourseRegistration.Infrastructure/Repositories/InstructorRatingRepository.cs b/api/CourseRegistration.Infrastructure/Repositories/InstructorRatingRepository.cs
new file mode 100644
index 0000000..ca96be5
--- /dev/null
+++ b/api/CourseRegistration.Infrastructure/Repositories/InstructorRatingRepository.cs
@@ -0,0 +1,103 @@
+using Microsoft.EntityFrameworkCore;
+using CourseRegistration.Domain.Entities;
+using CourseRegistration.Domain.Interfaces;
+using CourseRegistration.Infrastructure.Data;
+
+namespace CourseRegistration.Infrastructure.Repositories;
+
+/// <summary>
+/// InstructorRating repository implementation with specific operations
+/// </summary>
+public class InstructorRatingRepository : Repository<InstructorRating>, IInstructorRatingRepository
+{
+    /// <summary>
+    /// Initializes a new instance of the InstructorRatingRepository
+    /// </summary>
+    /// <param name="context">Database context</param>
+    public InstructorRatingRepository(CourseRegistrationDbContext context) : base(context)
+    {
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    public async Task<IEnumerable<InstructorRating>> GetByCourseIdAsync(Guid courseId)
+    {
+        return await _dbSet
+            .Include(ir => ir.Student)
+            .Include(ir => ir.Course)
+            .Where(ir => ir.CourseId == courseId)
+            .OrderByDescending(ir => ir.CreatedAt)
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    public async Task<IEnumerable<InstructorRating>> GetByStudentIdAsync(Guid studentId)
+    {
+        return await _dbSet
+            .Include(ir => ir.Course)
+            .Include(ir => ir.Student)
+            .Where(ir => ir.StudentId == studentId)
+            .OrderByDescending(ir => ir.CreatedAt)
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor across all courses
+    /// </summary>
+    public async Task<IEnumerable<InstructorRating>> GetByInstructorNameAsync(string instructorName)
+    {
+        return await _dbSet
+            .Include(ir => ir.Course)
+            .Include(ir => ir.Student)
+            .Where(ir => ir.Course.InstructorName == instructorName)
+            .OrderByDescending(ir => ir.CreatedAt)
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets a specific rating by student and course
+    /// </summary>
+    public async Task<InstructorRating?> GetByStudentAndCourseAsync(Guid studentId, Guid courseId)
+    {
+        return await _dbSet
+            .Include(ir => ir.Course)
+            .Include(ir => ir.Student)
+            .FirstOrDefaultAsync(ir => ir.StudentId == studentId && ir.CourseId == courseId);
+    }
+
+    /// <summary>
+    /// Checks if a student has already rated a course
+    /// </summary>
+    public async Task<bool> HasStudentRatedCourseAsync(Guid studentId, Guid courseId)
+    {
+        return await _dbSet
+            .AnyAsync(ir => ir.StudentId == studentId && ir.CourseId == courseId);
+    }
+
+    /// <summary>
+    /// Gets average rating for an instructor
+    /// </summary>
+    public async Task<double?> GetAverageRatingForInstructorAsync(string instructorName)
+    {
+        var ratings = await _dbSet
+            .Include(ir => ir.Course)
+            .Where(ir => ir.Course.InstructorName == instructorName)
+            .ToListAsync();
+
+        return ratings.Any() ? ratings.Average(ir => ir.Rating) : null;
+    }
+
+    /// <summary>
+    /// Gets rating with student and course details
+    /// </summary>
+    public async Task<InstructorRating?> GetWithDetailsAsync(Guid ratingId)
+    {
+        return await _dbSet
+            .Include(ir => ir.Course)
+            .Include(ir => ir.Student)
+            .FirstOrDefaultAsync(ir => ir.RatingId == ratingId);
+    }
+}
diff --git a/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs b/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs
index 63a4e8d..afea56e 100644
--- a/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs
+++ b/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs
@@ -18,6 +18,7 @@ public class UnitOfWork : IUnitOfWork
     private IStudentRepository? _students;
     private ICourseRepository? _courses;
     private IRegistrationRepository? _registrations;
+    private IInstructorRatingRepository? _instructorRatings;
 
     /// <summary>
     /// Initializes a new instance of the UnitOfWork
@@ -64,6 +65,18 @@ public IRegistrationRepository Registrations
         }
     }
 
+    /// <summary>
+    /// InstructorRating repository
+    /// </summary>
+    public IInstructorRatingRepository InstructorRatings
+    {
+        get
+        {
+            _instructorRatings ??= new InstructorRatingRepository(_context);
+            return _instructorRatings;
+        }
+    }
+
     /// <summary>
     /// Saves all changes made in this unit of work asynchronously
     /// </summary>
diff --git a/api/CourseRegistration.Tests/CourseRegistration.Tests.csproj b/api/CourseRegistration.Tests/CourseRegistration.Tests.csproj
index 17b82fa..f7a658d 100644
--- a/api/CourseRegistration.Tests/CourseRegistration.Tests.csproj
+++ b/api/CourseRegistration.Tests/CourseRegistration.Tests.csproj
@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.70" />
     <PackageReference Include="xunit" Version="2.6.5" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/api/CourseRegistration.Tests/Services/InstructorRatingServiceTests.cs b/api/CourseRegistration.Tests/Services/InstructorRatingServiceTests.cs
new file mode 100644
index 0000000..2ddd739
--- /dev/null
+++ b/api/CourseRegistration.Tests/Services/InstructorRatingServiceTests.cs
@@ -0,0 +1,540 @@
+using Xunit;
+using Moq;
+using AutoMapper;
+using CourseRegistration.Application.Services;
+using CourseRegistration.Application.DTOs;
+using CourseRegistration.Application.Mappings;
+using CourseRegistration.Domain.Entities;
+using CourseRegistration.Domain.Interfaces;
+using CourseRegistration.Domain.Enums;
+
+namespace CourseRegistration.Tests.Services;
+
+/// <summary>
+/// Unit tests for InstructorRatingService
+/// </summary>
+public class InstructorRatingServiceTests
+{
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly IMapper _mapper;
+    private readonly InstructorRatingService _service;
+    private readonly Mock<IInstructorRatingRepository> _mockRatingRepository;
+    private readonly Mock<ICourseRepository> _mockCourseRepository;
+    private readonly Mock<IStudentRepository> _mockStudentRepository;
+    private readonly Mock<IRegistrationRepository> _mockRegistrationRepository;
+
+    public InstructorRatingServiceTests()
+    {
+        // Setup AutoMapper
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.AddProfile<MappingProfile>();
+        });
+        _mapper = config.CreateMapper();
+
+        // Setup mocks
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _mockRatingRepository = new Mock<IInstructorRatingRepository>();
+        _mockCourseRepository = new Mock<ICourseRepository>();
+        _mockStudentRepository = new Mock<IStudentRepository>();
+        _mockRegistrationRepository = new Mock<IRegistrationRepository>();
+
+        _mockUnitOfWork.Setup(u => u.InstructorRatings).Returns(_mockRatingRepository.Object);
+        _mockUnitOfWork.Setup(u => u.Courses).Returns(_mockCourseRepository.Object);
+        _mockUnitOfWork.Setup(u => u.Students).Returns(_mockStudentRepository.Object);
+        _mockUnitOfWork.Setup(u => u.Registrations).Returns(_mockRegistrationRepository.Object);
+
+        _service = new InstructorRatingService(_mockUnitOfWork.Object, _mapper);
+    }
+
+    [Fact]
+    public async Task CreateRatingAsync_ValidData_ReturnsRatingDto()
+    {
+        // Arrange
+        var courseId = Guid.NewGuid();
+        var studentId = Guid.NewGuid();
+        var course = new Course
+        {
+            CourseId = courseId,
+            CourseName = "Test Course",
+            InstructorName = "Dr. Smith",
+            StartDate = DateTime.UtcNow.AddDays(1),
+            EndDate = DateTime.UtcNow.AddDays(30),
+            Schedule = "MWF 10-11",
+            IsActive = true
+        };
+        var student = new Student
+        {
+            StudentId = studentId,
+            FirstName = "John",
+            LastName = "Doe",
+            Email = "john.doe@test.com",
+            DateOfBirth = DateTime.UtcNow.AddYears(-20),
+            IsActive = true
+        };
+
+        var createDto = new CreateInstructorRatingDto
+        {
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 5,
+            Comment = "Excellent instructor!"
+        };
+
+        _mockCourseRepository.Setup(r => r.GetByIdAsync(courseId)).ReturnsAsync(course);
+        _mockStudentRepository.Setup(r => r.GetByIdAsync(studentId)).ReturnsAsync(student);
+        _mockRatingRepository.Setup(r => r.GetByStudentAndCourseAsync(studentId, courseId))
+            .ReturnsAsync((InstructorRating?)null);
+        _mockRegistrationRepository.Setup(r => r.IsStudentRegisteredForCourseAsync(studentId, courseId))
+            .ReturnsAsync(true);
+        _mockRatingRepository.Setup(r => r.AddAsync(It.IsAny<InstructorRating>()))
+            .ReturnsAsync((InstructorRating rating) => rating);
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync()).ReturnsAsync(1);
+        _mockRatingRepository.Setup(r => r.GetWithDetailsAsync(It.IsAny<Guid>()))
+            .ReturnsAsync((Guid id) => new InstructorRating
+            {
+                RatingId = id,
+                CourseId = courseId,
+                StudentId = studentId,
+                Rating = 5,
+                Comment = "Excellent instructor!",
+                Course = course,
+                Student = student
+            });
+
+        // Act
+        var result = await _service.CreateRatingAsync(createDto);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(5, result.Rating);
+        Assert.Equal("Excellent instructor!", result.Comment);
+        Assert.Equal("Test Course", result.CourseName);
+        Assert.Equal("Dr. Smith", result.InstructorName);
+        Assert.Equal("John Doe", result.StudentName);
+        _mockRatingRepository.Verify(r => r.AddAsync(It.IsAny<InstructorRating>()), Times.Once);
+        _mockUnitOfWork.Verify(u => u.SaveChangesAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateRatingAsync_CourseNotFound_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var createDto = new CreateInstructorRatingDto
+        {
+            CourseId = Guid.NewGuid(),
+            StudentId = Guid.NewGuid(),
+            Rating = 5,
+            Comment = "Great!"
+        };
+
+        _mockCourseRepository.Setup(r => r.GetByIdAsync(createDto.CourseId))
+            .ReturnsAsync((Course?)null);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            async () => await _service.CreateRatingAsync(createDto));
+    }
+
+    [Fact]
+    public async Task CreateRatingAsync_StudentNotFound_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var courseId = Guid.NewGuid();
+        var createDto = new CreateInstructorRatingDto
+        {
+            CourseId = courseId,
+            StudentId = Guid.NewGuid(),
+            Rating = 5,
+            Comment = "Great!"
+        };
+
+        var course = new Course
+        {
+            CourseId = courseId,
+            CourseName = "Test Course",
+            InstructorName = "Dr. Smith",
+            StartDate = DateTime.UtcNow.AddDays(1),
+            EndDate = DateTime.UtcNow.AddDays(30),
+            Schedule = "MWF 10-11",
+            IsActive = true
+        };
+
+        _mockCourseRepository.Setup(r => r.GetByIdAsync(courseId)).ReturnsAsync(course);
+        _mockStudentRepository.Setup(r => r.GetByIdAsync(createDto.StudentId))
+            .ReturnsAsync((Student?)null);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            async () => await _service.CreateRatingAsync(createDto));
+    }
+
+    [Fact]
+    public async Task CreateRatingAsync_StudentAlreadyRated_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var courseId = Guid.NewGuid();
+        var studentId = Guid.NewGuid();
+        var course = new Course
+        {
+            CourseId = courseId,
+            CourseName = "Test Course",
+            InstructorName = "Dr. Smith",
+            StartDate = DateTime.UtcNow.AddDays(1),
+            EndDate = DateTime.UtcNow.AddDays(30),
+            Schedule = "MWF 10-11",
+            IsActive = true
+        };
+        var student = new Student
+        {
+            StudentId = studentId,
+            FirstName = "John",
+            LastName = "Doe",
+            Email = "john.doe@test.com",
+            DateOfBirth = DateTime.UtcNow.AddYears(-20),
+            IsActive = true
+        };
+
+        var createDto = new CreateInstructorRatingDto
+        {
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 5,
+            Comment = "Great!"
+        };
+
+        var existingRating = new InstructorRating
+        {
+            RatingId = Guid.NewGuid(),
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 4,
+            Comment = "Good"
+        };
+
+        _mockCourseRepository.Setup(r => r.GetByIdAsync(courseId)).ReturnsAsync(course);
+        _mockStudentRepository.Setup(r => r.GetByIdAsync(studentId)).ReturnsAsync(student);
+        _mockRatingRepository.Setup(r => r.GetByStudentAndCourseAsync(studentId, courseId))
+            .ReturnsAsync(existingRating);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            async () => await _service.CreateRatingAsync(createDto));
+    }
+
+    [Fact]
+    public async Task CreateRatingAsync_StudentNotEnrolled_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var courseId = Guid.NewGuid();
+        var studentId = Guid.NewGuid();
+        var course = new Course
+        {
+            CourseId = courseId,
+            CourseName = "Test Course",
+            InstructorName = "Dr. Smith",
+            StartDate = DateTime.UtcNow.AddDays(1),
+            EndDate = DateTime.UtcNow.AddDays(30),
+            Schedule = "MWF 10-11",
+            IsActive = true
+        };
+        var student = new Student
+        {
+            StudentId = studentId,
+            FirstName = "John",
+            LastName = "Doe",
+            Email = "john.doe@test.com",
+            DateOfBirth = DateTime.UtcNow.AddYears(-20),
+            IsActive = true
+        };
+
+        var createDto = new CreateInstructorRatingDto
+        {
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 5,
+            Comment = "Great!"
+        };
+
+        _mockCourseRepository.Setup(r => r.GetByIdAsync(courseId)).ReturnsAsync(course);
+        _mockStudentRepository.Setup(r => r.GetByIdAsync(studentId)).ReturnsAsync(student);
+        _mockRatingRepository.Setup(r => r.GetByStudentAndCourseAsync(studentId, courseId))
+            .ReturnsAsync((InstructorRating?)null);
+        _mockRegistrationRepository.Setup(r => r.IsStudentRegisteredForCourseAsync(studentId, courseId))
+            .ReturnsAsync(false);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            async () => await _service.CreateRatingAsync(createDto));
+    }
+
+    [Fact]
+    public async Task GetRatingByIdAsync_ValidId_ReturnsRatingDto()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        var courseId = Guid.NewGuid();
+        var studentId = Guid.NewGuid();
+        
+        var rating = new InstructorRating
+        {
+            RatingId = ratingId,
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 4,
+            Comment = "Good course",
+            Course = new Course
+            {
+                CourseId = courseId,
+                CourseName = "Test Course",
+                InstructorName = "Dr. Smith",
+                StartDate = DateTime.UtcNow.AddDays(1),
+                EndDate = DateTime.UtcNow.AddDays(30),
+                Schedule = "MWF 10-11"
+            },
+            Student = new Student
+            {
+                StudentId = studentId,
+                FirstName = "Jane",
+                LastName = "Smith",
+                Email = "jane.smith@test.com",
+                DateOfBirth = DateTime.UtcNow.AddYears(-22)
+            }
+        };
+
+        _mockRatingRepository.Setup(r => r.GetWithDetailsAsync(ratingId)).ReturnsAsync(rating);
+
+        // Act
+        var result = await _service.GetRatingByIdAsync(ratingId);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(ratingId, result.RatingId);
+        Assert.Equal(4, result.Rating);
+        Assert.Equal("Good course", result.Comment);
+        Assert.Equal("Test Course", result.CourseName);
+        Assert.Equal("Dr. Smith", result.InstructorName);
+        Assert.Equal("Jane Smith", result.StudentName);
+    }
+
+    [Fact]
+    public async Task GetRatingByIdAsync_InvalidId_ReturnsNull()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        _mockRatingRepository.Setup(r => r.GetWithDetailsAsync(ratingId))
+            .ReturnsAsync((InstructorRating?)null);
+
+        // Act
+        var result = await _service.GetRatingByIdAsync(ratingId);
+
+        // Assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public async Task UpdateRatingAsync_ValidData_ReturnsUpdatedRatingDto()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        var courseId = Guid.NewGuid();
+        var studentId = Guid.NewGuid();
+
+        var existingRating = new InstructorRating
+        {
+            RatingId = ratingId,
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 4,
+            Comment = "Good"
+        };
+
+        var updateDto = new UpdateInstructorRatingDto
+        {
+            Rating = 5,
+            Comment = "Excellent!"
+        };
+
+        var updatedRating = new InstructorRating
+        {
+            RatingId = ratingId,
+            CourseId = courseId,
+            StudentId = studentId,
+            Rating = 5,
+            Comment = "Excellent!",
+            Course = new Course
+            {
+                CourseId = courseId,
+                CourseName = "Test Course",
+                InstructorName = "Dr. Smith",
+                StartDate = DateTime.UtcNow.AddDays(1),
+                EndDate = DateTime.UtcNow.AddDays(30),
+                Schedule = "MWF 10-11"
+            },
+            Student = new Student
+            {
+                StudentId = studentId,
+                FirstName = "John",
+                LastName = "Doe",
+                Email = "john.doe@test.com",
+                DateOfBirth = DateTime.UtcNow.AddYears(-20)
+            }
+        };
+
+        _mockRatingRepository.Setup(r => r.GetByIdAsync(ratingId)).ReturnsAsync(existingRating);
+        _mockRatingRepository.Setup(r => r.Update(It.IsAny<InstructorRating>()));
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync()).ReturnsAsync(1);
+        _mockRatingRepository.Setup(r => r.GetWithDetailsAsync(ratingId)).ReturnsAsync(updatedRating);
+
+        // Act
+        var result = await _service.UpdateRatingAsync(ratingId, updateDto);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(5, result.Rating);
+        Assert.Equal("Excellent!", result.Comment);
+        _mockRatingRepository.Verify(r => r.Update(It.IsAny<InstructorRating>()), Times.Once);
+        _mockUnitOfWork.Verify(u => u.SaveChangesAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateRatingAsync_InvalidId_ReturnsNull()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        var updateDto = new UpdateInstructorRatingDto
+        {
+            Rating = 5,
+            Comment = "Excellent!"
+        };
+
+        _mockRatingRepository.Setup(r => r.GetByIdAsync(ratingId))
+            .ReturnsAsync((InstructorRating?)null);
+
+        // Act
+        var result = await _service.UpdateRatingAsync(ratingId, updateDto);
+
+        // Assert
+        Assert.Null(result);
+        _mockRatingRepository.Verify(r => r.Update(It.IsAny<InstructorRating>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task DeleteRatingAsync_ValidId_ReturnsTrue()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        var rating = new InstructorRating
+        {
+            RatingId = ratingId,
+            CourseId = Guid.NewGuid(),
+            StudentId = Guid.NewGuid(),
+            Rating = 4,
+            Comment = "Good"
+        };
+
+        _mockRatingRepository.Setup(r => r.GetByIdAsync(ratingId)).ReturnsAsync(rating);
+        _mockRatingRepository.Setup(r => r.Remove(rating));
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync()).ReturnsAsync(1);
+
+        // Act
+        var result = await _service.DeleteRatingAsync(ratingId);
+
+        // Assert
+        Assert.True(result);
+        _mockRatingRepository.Verify(r => r.Remove(rating), Times.Once);
+        _mockUnitOfWork.Verify(u => u.SaveChangesAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async Task DeleteRatingAsync_InvalidId_ReturnsFalse()
+    {
+        // Arrange
+        var ratingId = Guid.NewGuid();
+        _mockRatingRepository.Setup(r => r.GetByIdAsync(ratingId))
+            .ReturnsAsync((InstructorRating?)null);
+
+        // Act
+        var result = await _service.DeleteRatingAsync(ratingId);
+
+        // Assert
+        Assert.False(result);
+        _mockRatingRepository.Verify(r => r.Remove(It.IsAny<InstructorRating>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task GetInstructorStatsAsync_ValidInstructor_ReturnsStats()
+    {
+        // Arrange
+        var instructorName = "Dr. Smith";
+        var courseId1 = Guid.NewGuid();
+        var courseId2 = Guid.NewGuid();
+
+        var ratings = new List<InstructorRating>
+        {
+            new InstructorRating
+            {
+                RatingId = Guid.NewGuid(),
+                CourseId = courseId1,
+                StudentId = Guid.NewGuid(),
+                Rating = 5,
+                Course = new Course { CourseId = courseId1, InstructorName = instructorName, CourseName = "Course1", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow.AddDays(30), Schedule = "MWF" }
+            },
+            new InstructorRating
+            {
+                RatingId = Guid.NewGuid(),
+                CourseId = courseId2,
+                StudentId = Guid.NewGuid(),
+                Rating = 4,
+                Course = new Course { CourseId = courseId2, InstructorName = instructorName, CourseName = "Course2", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow.AddDays(30), Schedule = "TTh" }
+            },
+            new InstructorRating
+            {
+                RatingId = Guid.NewGuid(),
+                CourseId = courseId1,
+                StudentId = Guid.NewGuid(),
+                Rating = 5,
+                Course = new Course { CourseId = courseId1, InstructorName = instructorName, CourseName = "Course1", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow.AddDays(30), Schedule = "MWF" }
+            }
+        };
+
+        var courses = new List<Course>
+        {
+            new Course { CourseId = courseId1, InstructorName = instructorName, CourseName = "Course1", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow.AddDays(30), Schedule = "MWF" },
+            new Course { CourseId = courseId2, InstructorName = instructorName, CourseName = "Course2", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow.AddDays(30), Schedule = "TTh" }
+        };
+
+        _mockRatingRepository.Setup(r => r.GetByInstructorNameAsync(instructorName))
+            .ReturnsAsync(ratings);
+        _mockCourseRepository.Setup(r => r.GetCoursesByInstructorAsync(instructorName))
+            .ReturnsAsync(courses);
+
+        // Act
+        var result = await _service.GetInstructorStatsAsync(instructorName);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(instructorName, result.InstructorName);
+        Assert.Equal(4.67, Math.Round(result.AverageRating, 2)); // (5 + 4 + 5) / 3 = 4.67
+        Assert.Equal(3, result.TotalRatings);
+        Assert.Equal(2, result.FiveStarCount);
+        Assert.Equal(1, result.FourStarCount);
+        Assert.Equal(0, result.ThreeStarCount);
+        Assert.Equal(2, result.CourseIds.Count);
+    }
+
+    [Fact]
+    public async Task GetInstructorStatsAsync_NoRatings_ReturnsNull()
+    {
+        // Arrange
+        var instructorName = "Dr. Nobody";
+        _mockRatingRepository.Setup(r => r.GetByInstructorNameAsync(instructorName))
+            .ReturnsAsync(new List<InstructorRating>());
+
+        // Act
+        var result = await _service.GetInstructorStatsAsync(instructorName);
+
+        // Assert
+        Assert.Null(result);
+    }
+}