diff --git a/api/CourseRegistration.API/Controllers/WaitlistController.cs b/api/CourseRegistration.API/Controllers/WaitlistController.cs
new file mode 100644
index 0000000..5763375
--- /dev/null
+++ b/api/CourseRegistration.API/Controllers/WaitlistController.cs
@@ -0,0 +1,288 @@
+using Microsoft.AspNetCore.Mvc;
+using CourseRegistration.Application.DTOs;
+using CourseRegistration.Application.Interfaces;
+
+namespace CourseRegistration.API.Controllers;
+
+/// <summary>
+/// Controller for waitlist management operations
+/// </summary>
+[ApiController]
+[Route("api/[controller]")]
+[Produces("application/json")]
+public class WaitlistController : ControllerBase
+{
+    private readonly IWaitlistService _waitlistService;
+    private readonly ILogger<WaitlistController> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the WaitlistController
+    /// </summary>
+    public WaitlistController(IWaitlistService waitlistService, ILogger<WaitlistController> logger)
+    {
+        _waitlistService = waitlistService ?? throw new ArgumentNullException(nameof(waitlistService));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Adds a student to a course waitlist
+    /// </summary>
+    /// <param name="createWaitlistEntryDto">Waitlist entry creation data</param>
+    /// <returns>Created waitlist entry</returns>
+    [HttpPost]
+    [ProducesResponseType(typeof(ApiResponseDto<WaitlistEntryDto>), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<ApiResponseDto<WaitlistEntryDto>>> JoinWaitlist([FromBody] CreateWaitlistEntryDto createWaitlistEntryDto)
+    {
+        _logger.LogInformation("Student {StudentId} attempting to join waitlist for course {CourseId}", 
+            createWaitlistEntryDto.StudentId, createWaitlistEntryDto.CourseId);
+
+        try
+        {
+            var waitlistEntry = await _waitlistService.JoinWaitlistAsync(createWaitlistEntryDto);
+            return CreatedAtAction(
+                nameof(GetWaitlistEntry),
+                new { id = waitlistEntry.WaitlistEntryId },
+                new ApiResponseDto<WaitlistEntryDto>
+                {
+                    Success = true,
+                    Message = $"Successfully joined waitlist at position {waitlistEntry.Position}",
+                    Data = waitlistEntry
+                });
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning("Failed to join waitlist: {Message}", ex.Message);
+            return BadRequest(new ApiResponseDto<object>
+            {
+                Success = false,
+                Message = ex.Message
+            });
+        }
+    }
+
+    /// <summary>
+    /// Gets a specific waitlist entry by ID
+    /// </summary>
+    /// <param name="id">Waitlist entry ID</param>
+    /// <returns>Waitlist entry details</returns>
+    [HttpGet("{id}")]
+    [ProducesResponseType(typeof(ApiResponseDto<WaitlistEntryDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<WaitlistEntryDto>>> GetWaitlistEntry(Guid id)
+    {
+        _logger.LogInformation("Getting waitlist entry {Id}", id);
+
+        var waitlistEntry = await _waitlistService.GetWaitlistEntryAsync(id);
+
+        if (waitlistEntry == null)
+        {
+            return NotFound(new ApiResponseDto<object>
+            {
+                Success = false,
+                Message = "Waitlist entry not found"
+            });
+        }
+
+        return Ok(new ApiResponseDto<WaitlistEntryDto>
+        {
+            Success = true,
+            Data = waitlistEntry
+        });
+    }
+
+    /// <summary>
+    /// Gets active waitlist entries for a specific course
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>List of waitlist entries for the course</returns>
+    [HttpGet("course/{courseId}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<WaitlistEntryDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<WaitlistEntryDto>>>> GetCourseWaitlist(Guid courseId)
+    {
+        _logger.LogInformation("Getting waitlist for course {CourseId}", courseId);
+
+        var waitlistEntries = await _waitlistService.GetCourseWaitlistAsync(courseId);
+
+        return Ok(new ApiResponseDto<IEnumerable<WaitlistEntryDto>>
+        {
+            Success = true,
+            Data = waitlistEntries,
+            Message = $"Found {waitlistEntries.Count()} entries in waitlist"
+        });
+    }
+
+    /// <summary>
+    /// Gets active waitlist entries for a specific student
+    /// </summary>
+    /// <param name="studentId">Student ID</param>
+    /// <returns>List of waitlist entries for the student</returns>
+    [HttpGet("student/{studentId}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<WaitlistEntryDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<WaitlistEntryDto>>>> GetStudentWaitlists(Guid studentId)
+    {
+        _logger.LogInformation("Getting waitlists for student {StudentId}", studentId);
+
+        var waitlistEntries = await _waitlistService.GetStudentWaitlistsAsync(studentId);
+
+        return Ok(new ApiResponseDto<IEnumerable<WaitlistEntryDto>>
+        {
+            Success = true,
+            Data = waitlistEntries,
+            Message = $"Student is on {waitlistEntries.Count()} waitlist(s)"
+        });
+    }
+
+    /// <summary>
+    /// Removes a student from a waitlist
+    /// </summary>
+    /// <param name="id">Waitlist entry ID</param>
+    /// <returns>Success status</returns>
+    [HttpDelete("{id}")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<object>>> LeaveWaitlist(Guid id)
+    {
+        _logger.LogInformation("Attempting to remove waitlist entry {Id}", id);
+
+        var result = await _waitlistService.LeaveWaitlistAsync(id);
+
+        if (!result)
+        {
+            return NotFound(new ApiResponseDto<object>
+            {
+                Success = false,
+                Message = "Waitlist entry not found or already inactive"
+            });
+        }
+
+        return Ok(new ApiResponseDto<object>
+        {
+            Success = true,
+            Message = "Successfully left the waitlist"
+        });
+    }
+
+    /// <summary>
+    /// Updates a waitlist entry (admin function)
+    /// </summary>
+    /// <param name="id">Waitlist entry ID</param>
+    /// <param name="updateDto">Update data</param>
+    /// <returns>Updated waitlist entry</returns>
+    [HttpPatch("{id}")]
+    [ProducesResponseType(typeof(ApiResponseDto<WaitlistEntryDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<ApiResponseDto<WaitlistEntryDto>>> UpdateWaitlistEntry(
+        Guid id,
+        [FromBody] UpdateWaitlistEntryDto updateDto)
+    {
+        _logger.LogInformation("Updating waitlist entry {Id}", id);
+
+        try
+        {
+            var updatedEntry = await _waitlistService.UpdateWaitlistEntryAsync(id, updateDto);
+
+            if (updatedEntry == null)
+            {
+                return NotFound(new ApiResponseDto<object>
+                {
+                    Success = false,
+                    Message = "Waitlist entry not found"
+                });
+            }
+
+            return Ok(new ApiResponseDto<WaitlistEntryDto>
+            {
+                Success = true,
+                Message = "Waitlist entry updated successfully",
+                Data = updatedEntry
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning("Failed to update waitlist entry: {Message}", ex.Message);
+            return BadRequest(new ApiResponseDto<object>
+            {
+                Success = false,
+                Message = ex.Message
+            });
+        }
+    }
+
+    /// <summary>
+    /// Clears the entire waitlist for a course (admin function)
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>Success status</returns>
+    [HttpDelete("course/{courseId}/clear")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<object>>> ClearWaitlist(Guid courseId)
+    {
+        _logger.LogInformation("Clearing waitlist for course {CourseId}", courseId);
+
+        await _waitlistService.ClearWaitlistAsync(courseId);
+
+        return Ok(new ApiResponseDto<object>
+        {
+            Success = true,
+            Message = "Waitlist cleared successfully"
+        });
+    }
+
+    /// <summary>
+    /// Notifies the next student on the waitlist (admin/system function)
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>Success status</returns>
+    [HttpPost("course/{courseId}/notify-next")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<object>>> NotifyNextStudent(Guid courseId)
+    {
+        _logger.LogInformation("Notifying next student on waitlist for course {CourseId}", courseId);
+
+        await _waitlistService.NotifyNextStudentAsync(courseId);
+
+        return Ok(new ApiResponseDto<object>
+        {
+            Success = true,
+            Message = "Next student notified successfully"
+        });
+    }
+
+    /// <summary>
+    /// Reorders waitlist entries for a course (admin function)
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <param name="newPositions">Dictionary of waitlist entry IDs and their new positions</param>
+    /// <returns>Success status</returns>
+    [HttpPut("course/{courseId}/reorder")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<ApiResponseDto<object>>> ReorderWaitlist(
+        Guid courseId,
+        [FromBody] Dictionary<Guid, int> newPositions)
+    {
+        _logger.LogInformation("Reordering waitlist for course {CourseId}", courseId);
+
+        try
+        {
+            await _waitlistService.ReorderWaitlistAsync(courseId, newPositions);
+
+            return Ok(new ApiResponseDto<object>
+            {
+                Success = true,
+                Message = "Waitlist reordered successfully"
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning("Failed to reorder waitlist: {Message}", ex.Message);
+            return BadRequest(new ApiResponseDto<object>
+            {
+                Success = false,
+                Message = ex.Message
+            });
+        }
+    }
+}
diff --git a/api/CourseRegistration.API/Program.cs b/api/CourseRegistration.API/Program.cs
index 2c174da..c15a0aa 100644
--- a/api/CourseRegistration.API/Program.cs
+++ b/api/CourseRegistration.API/Program.cs
@@ -60,11 +60,14 @@
 builder.Services.AddScoped<IStudentRepository, StudentRepository>();
 builder.Services.AddScoped<ICourseRepository, CourseRepository>();
 builder.Services.AddScoped<IRegistrationRepository, RegistrationRepository>();
+builder.Services.AddScoped<IWaitlistRepository, WaitlistRepository>();
 builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 
 // Register services
 builder.Services.AddScoped<IStudentService, StudentService>();
 builder.Services.AddScoped<ICourseService, CourseService>();
+builder.Services.AddScoped<INotificationService, NotificationService>();
+builder.Services.AddScoped<IWaitlistService, WaitlistService>();
 builder.Services.AddScoped<IRegistrationService, RegistrationService>();
 
 // Add CORS policy for development
diff --git a/api/CourseRegistration.Application/DTOs/CourseDtos.cs b/api/CourseRegistration.Application/DTOs/CourseDtos.cs
index 661dedc..6d6a0f9 100644
--- a/api/CourseRegistration.Application/DTOs/CourseDtos.cs
+++ b/api/CourseRegistration.Application/DTOs/CourseDtos.cs
@@ -34,6 +34,11 @@ public class CreateCourseDto
     /// Course schedule
     /// </summary>
     public string Schedule { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Maximum number of students allowed
+    /// </summary>
+    public int MaxEnrollment { get; set; } = 30;
 }
 
 /// <summary>
@@ -70,6 +75,11 @@ public class UpdateCourseDto
     /// Course schedule
     /// </summary>
     public string Schedule { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Maximum number of students allowed
+    /// </summary>
+    public int MaxEnrollment { get; set; } = 30;
 }
 
 /// <summary>
@@ -117,6 +127,21 @@ public class CourseDto
     /// </summary>
     public int CurrentEnrollment { get; set; }
 
+    /// <summary>
+    /// Maximum enrollment capacity
+    /// </summary>
+    public int MaxEnrollment { get; set; }
+
+    /// <summary>
+    /// Indicates if the course is full
+    /// </summary>
+    public bool IsFull { get; set; }
+
+    /// <summary>
+    /// Number of students on the waitlist
+    /// </summary>
+    public int WaitlistCount { get; set; }
+
     /// <summary>
     /// Indicates if the course is active
     /// </summary>
diff --git a/api/CourseRegistration.Application/DTOs/WaitlistDtos.cs b/api/CourseRegistration.Application/DTOs/WaitlistDtos.cs
new file mode 100644
index 0000000..1ae1078
--- /dev/null
+++ b/api/CourseRegistration.Application/DTOs/WaitlistDtos.cs
@@ -0,0 +1,111 @@
+using CourseRegistration.Domain.Enums;
+
+namespace CourseRegistration.Application.DTOs;
+
+/// <summary>
+/// Data transfer object for creating a waitlist entry
+/// </summary>
+public class CreateWaitlistEntryDto
+{
+    /// <summary>
+    /// Student ID
+    /// </summary>
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Course ID
+    /// </summary>
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Notification preference
+    /// </summary>
+    public NotificationType NotificationPreference { get; set; } = NotificationType.Email;
+}
+
+/// <summary>
+/// Data transfer object for waitlist entry response
+/// </summary>
+public class WaitlistEntryDto
+{
+    /// <summary>
+    /// Waitlist entry ID
+    /// </summary>
+    public Guid WaitlistEntryId { get; set; }
+
+    /// <summary>
+    /// Student ID
+    /// </summary>
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Student's full name
+    /// </summary>
+    public string StudentName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Student's email
+    /// </summary>
+    public string StudentEmail { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Course ID
+    /// </summary>
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Course name
+    /// </summary>
+    public string CourseName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Position in the waitlist
+    /// </summary>
+    public int Position { get; set; }
+
+    /// <summary>
+    /// Date and time when joined the waitlist
+    /// </summary>
+    public DateTime JoinedAt { get; set; }
+
+    /// <summary>
+    /// Notification preference
+    /// </summary>
+    public NotificationType NotificationPreference { get; set; }
+
+    /// <summary>
+    /// Indicates if still active on waitlist
+    /// </summary>
+    public bool IsActive { get; set; }
+
+    /// <summary>
+    /// Date and time when notified
+    /// </summary>
+    public DateTime? NotifiedAt { get; set; }
+
+    /// <summary>
+    /// Notes about the waitlist entry
+    /// </summary>
+    public string? Notes { get; set; }
+}
+
+/// <summary>
+/// Data transfer object for updating waitlist entry
+/// </summary>
+public class UpdateWaitlistEntryDto
+{
+    /// <summary>
+    /// New position in the waitlist (for admin reordering)
+    /// </summary>
+    public int? Position { get; set; }
+
+    /// <summary>
+    /// Notification preference
+    /// </summary>
+    public NotificationType? NotificationPreference { get; set; }
+
+    /// <summary>
+    /// Notes about the waitlist entry
+    /// </summary>
+    public string? Notes { get; set; }
+}
diff --git a/api/CourseRegistration.Application/Interfaces/INotificationService.cs b/api/CourseRegistration.Application/Interfaces/INotificationService.cs
new file mode 100644
index 0000000..55bdafb
--- /dev/null
+++ b/api/CourseRegistration.Application/Interfaces/INotificationService.cs
@@ -0,0 +1,29 @@
+using CourseRegistration.Domain.Enums;
+
+namespace CourseRegistration.Application.Interfaces;
+
+/// <summary>
+/// Service interface for sending notifications
+/// </summary>
+public interface INotificationService
+{
+    /// <summary>
+    /// Sends a notification to a student about an available spot
+    /// </summary>
+    Task SendWaitlistNotificationAsync(
+        string studentEmail, 
+        string studentName, 
+        string courseName, 
+        int position,
+        NotificationType notificationType);
+
+    /// <summary>
+    /// Sends an email notification
+    /// </summary>
+    Task SendEmailAsync(string toEmail, string subject, string body);
+
+    /// <summary>
+    /// Sends an in-app notification (placeholder for future implementation)
+    /// </summary>
+    Task SendInAppNotificationAsync(Guid studentId, string message);
+}
diff --git a/api/CourseRegistration.Application/Interfaces/IWaitlistService.cs b/api/CourseRegistration.Application/Interfaces/IWaitlistService.cs
new file mode 100644
index 0000000..aecaaa1
--- /dev/null
+++ b/api/CourseRegistration.Application/Interfaces/IWaitlistService.cs
@@ -0,0 +1,59 @@
+using CourseRegistration.Application.DTOs;
+
+namespace CourseRegistration.Application.Interfaces;
+
+/// <summary>
+/// Service interface for waitlist operations
+/// </summary>
+public interface IWaitlistService
+{
+    /// <summary>
+    /// Adds a student to a course waitlist
+    /// </summary>
+    Task<WaitlistEntryDto> JoinWaitlistAsync(CreateWaitlistEntryDto createWaitlistEntryDto);
+
+    /// <summary>
+    /// Removes a student from a course waitlist
+    /// </summary>
+    Task<bool> LeaveWaitlistAsync(Guid waitlistEntryId);
+
+    /// <summary>
+    /// Gets active waitlist entries for a course
+    /// </summary>
+    Task<IEnumerable<WaitlistEntryDto>> GetCourseWaitlistAsync(Guid courseId);
+
+    /// <summary>
+    /// Gets a student's active waitlist entries
+    /// </summary>
+    Task<IEnumerable<WaitlistEntryDto>> GetStudentWaitlistsAsync(Guid studentId);
+
+    /// <summary>
+    /// Gets a specific waitlist entry by ID
+    /// </summary>
+    Task<WaitlistEntryDto?> GetWaitlistEntryAsync(Guid waitlistEntryId);
+
+    /// <summary>
+    /// Updates a waitlist entry (admin function for reordering or updating preferences)
+    /// </summary>
+    Task<WaitlistEntryDto?> UpdateWaitlistEntryAsync(Guid waitlistEntryId, UpdateWaitlistEntryDto updateDto);
+
+    /// <summary>
+    /// Notifies the next student on the waitlist when a spot becomes available
+    /// </summary>
+    Task NotifyNextStudentAsync(Guid courseId);
+
+    /// <summary>
+    /// Clears the entire waitlist for a course (admin function)
+    /// </summary>
+    Task<bool> ClearWaitlistAsync(Guid courseId);
+
+    /// <summary>
+    /// Reorders waitlist entries (admin function)
+    /// </summary>
+    Task<bool> ReorderWaitlistAsync(Guid courseId, Dictionary<Guid, int> newPositions);
+
+    /// <summary>
+    /// Checks if a student is on the waitlist for a course
+    /// </summary>
+    Task<bool> IsStudentOnWaitlistAsync(Guid studentId, Guid courseId);
+}
diff --git a/api/CourseRegistration.Application/Mappings/MappingProfile.cs b/api/CourseRegistration.Application/Mappings/MappingProfile.cs
index 10be3ee..9d138a7 100644
--- a/api/CourseRegistration.Application/Mappings/MappingProfile.cs
+++ b/api/CourseRegistration.Application/Mappings/MappingProfile.cs
@@ -21,32 +21,38 @@ public MappingProfile()
             .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.IsActive, opt => opt.Ignore())
-            .ForMember(dest => dest.Registrations, opt => opt.Ignore());
+            .ForMember(dest => dest.Registrations, opt => opt.Ignore())
+            .ForMember(dest => dest.WaitlistEntries, opt => opt.Ignore());
 
         CreateMap<UpdateStudentDto, Student>()
             .ForMember(dest => dest.StudentId, opt => opt.Ignore())
             .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.IsActive, opt => opt.Ignore())
-            .ForMember(dest => dest.Registrations, opt => opt.Ignore());
+            .ForMember(dest => dest.Registrations, opt => opt.Ignore())
+            .ForMember(dest => dest.WaitlistEntries, opt => opt.Ignore());
 
         // Course mappings
         CreateMap<Course, CourseDto>()
-            .ForMember(dest => dest.CurrentEnrollment, opt => opt.MapFrom(src => src.CurrentEnrollment));
+            .ForMember(dest => dest.CurrentEnrollment, opt => opt.MapFrom(src => src.CurrentEnrollment))
+            .ForMember(dest => dest.IsFull, opt => opt.MapFrom(src => src.IsFull))
+            .ForMember(dest => dest.WaitlistCount, opt => opt.MapFrom(src => src.WaitlistEntries.Count(w => w.IsActive)));
 
         CreateMap<CreateCourseDto, Course>()
             .ForMember(dest => dest.CourseId, opt => opt.Ignore())
             .ForMember(dest => dest.IsActive, opt => opt.Ignore())
             .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
-            .ForMember(dest => dest.Registrations, opt => opt.Ignore());
+            .ForMember(dest => dest.Registrations, opt => opt.Ignore())
+            .ForMember(dest => dest.WaitlistEntries, opt => opt.Ignore());
 
         CreateMap<UpdateCourseDto, Course>()
             .ForMember(dest => dest.CourseId, opt => opt.Ignore())
             .ForMember(dest => dest.IsActive, opt => opt.Ignore())
             .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
             .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
-            .ForMember(dest => dest.Registrations, opt => opt.Ignore());
+            .ForMember(dest => dest.Registrations, opt => opt.Ignore())
+            .ForMember(dest => dest.WaitlistEntries, opt => opt.Ignore());
 
         // Registration mappings
         CreateMap<Registration, RegistrationDto>()
@@ -69,5 +75,32 @@ public MappingProfile()
             .ForMember(dest => dest.RegistrationDate, opt => opt.Ignore())
             .ForMember(dest => dest.Student, opt => opt.Ignore())
             .ForMember(dest => dest.Course, opt => opt.Ignore());
+
+        // Waitlist mappings
+        CreateMap<WaitlistEntry, WaitlistEntryDto>()
+            .ForMember(dest => dest.StudentName, opt => opt.MapFrom(src => src.Student.FullName))
+            .ForMember(dest => dest.StudentEmail, opt => opt.MapFrom(src => src.Student.Email))
+            .ForMember(dest => dest.CourseName, opt => opt.MapFrom(src => src.Course.CourseName));
+
+        CreateMap<CreateWaitlistEntryDto, WaitlistEntry>()
+            .ForMember(dest => dest.WaitlistEntryId, opt => opt.Ignore())
+            .ForMember(dest => dest.JoinedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.Position, opt => opt.Ignore())
+            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
+            .ForMember(dest => dest.NotifiedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.Notes, opt => opt.Ignore())
+            .ForMember(dest => dest.Student, opt => opt.Ignore())
+            .ForMember(dest => dest.Course, opt => opt.Ignore());
+
+        CreateMap<UpdateWaitlistEntryDto, WaitlistEntry>()
+            .ForMember(dest => dest.WaitlistEntryId, opt => opt.Ignore())
+            .ForMember(dest => dest.StudentId, opt => opt.Ignore())
+            .ForMember(dest => dest.CourseId, opt => opt.Ignore())
+            .ForMember(dest => dest.JoinedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
+            .ForMember(dest => dest.NotifiedAt, opt => opt.Ignore())
+            .ForMember(dest => dest.Student, opt => opt.Ignore())
+            .ForMember(dest => dest.Course, opt => opt.Ignore())
+            .ForAllMembers(opts => opts.Condition((src, dest, srcMember) => srcMember != null));
     }
 }
\ No newline at end of file
diff --git a/api/CourseRegistration.Application/Services/NotificationService.cs b/api/CourseRegistration.Application/Services/NotificationService.cs
new file mode 100644
index 0000000..3715f1a
--- /dev/null
+++ b/api/CourseRegistration.Application/Services/NotificationService.cs
@@ -0,0 +1,78 @@
+using CourseRegistration.Application.Interfaces;
+using CourseRegistration.Domain.Enums;
+using Microsoft.Extensions.Logging;
+
+namespace CourseRegistration.Application.Services;
+
+/// <summary>
+/// Service implementation for sending notifications
+/// </summary>
+public class NotificationService : INotificationService
+{
+    private readonly ILogger<NotificationService> _logger;
+
+    public NotificationService(ILogger<NotificationService> logger)
+    {
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Sends a notification to a student about an available spot
+    /// </summary>
+    public async Task SendWaitlistNotificationAsync(
+        string studentEmail,
+        string studentName,
+        string courseName,
+        int position,
+        NotificationType notificationType)
+    {
+        var subject = $"Course Waitlist Update - {courseName}";
+        var body = $"Dear {studentName},\n\n" +
+                   $"A spot has become available in the course '{courseName}'.\n" +
+                   $"You are currently in position {position} on the waitlist.\n\n" +
+                   $"Please log in to your account to register for the course.\n\n" +
+                   $"Best regards,\n" +
+                   $"Course Registration System";
+
+        switch (notificationType)
+        {
+            case NotificationType.Email:
+                await SendEmailAsync(studentEmail, subject, body);
+                break;
+            case NotificationType.InApp:
+                // For now, just log - in-app notifications would require additional infrastructure
+                _logger.LogInformation($"In-app notification would be sent to {studentEmail}: {subject}");
+                break;
+            case NotificationType.Both:
+                await SendEmailAsync(studentEmail, subject, body);
+                _logger.LogInformation($"In-app notification would be sent to {studentEmail}: {subject}");
+                break;
+        }
+    }
+
+    /// <summary>
+    /// Sends an email notification (simulated for now)
+    /// </summary>
+    public Task SendEmailAsync(string toEmail, string subject, string body)
+    {
+        // In a real implementation, this would integrate with an email service like SendGrid, AWS SES, etc.
+        // For now, we'll just log the email
+        _logger.LogInformation($"EMAIL NOTIFICATION\n" +
+                               $"To: {toEmail}\n" +
+                               $"Subject: {subject}\n" +
+                               $"Body: {body}");
+
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Sends an in-app notification (placeholder for future implementation)
+    /// </summary>
+    public Task SendInAppNotificationAsync(Guid studentId, string message)
+    {
+        // Placeholder for future implementation
+        // This would typically store a notification in a database or send via SignalR/WebSocket
+        _logger.LogInformation($"In-app notification for student {studentId}: {message}");
+        return Task.CompletedTask;
+    }
+}
diff --git a/api/CourseRegistration.Application/Services/RegistrationService.cs b/api/CourseRegistration.Application/Services/RegistrationService.cs
index eaf3e6b..6c71e18 100644
--- a/api/CourseRegistration.Application/Services/RegistrationService.cs
+++ b/api/CourseRegistration.Application/Services/RegistrationService.cs
@@ -14,14 +14,16 @@ public class RegistrationService : IRegistrationService
 {
     private readonly IUnitOfWork _unitOfWork;
     private readonly IMapper _mapper;
+    private readonly IWaitlistService _waitlistService;
 
     /// <summary>
     /// Initializes a new instance of the RegistrationService
     /// </summary>
-    public RegistrationService(IUnitOfWork unitOfWork, IMapper mapper)
+    public RegistrationService(IUnitOfWork unitOfWork, IMapper mapper, IWaitlistService waitlistService)
     {
         _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
         _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
+        _waitlistService = waitlistService ?? throw new ArgumentNullException(nameof(waitlistService));
     }
 
     /// <summary>
@@ -113,6 +115,14 @@ public async Task<RegistrationDto> CreateRegistrationAsync(CreateRegistrationDto
             throw new InvalidOperationException("Student is already registered for this course.");
         }
 
+        // Check if course is full
+        if (course.IsFull)
+        {
+            throw new InvalidOperationException(
+                $"Course is full (max enrollment: {course.MaxEnrollment}). " +
+                "Please join the waitlist instead.");
+        }
+
         var registration = _mapper.Map<Registration>(createRegistrationDto);
         registration.Status = RegistrationStatus.Pending;
         registration.RegistrationDate = DateTime.UtcNow;
@@ -171,9 +181,19 @@ public async Task<bool> CancelRegistrationAsync(Guid id)
             throw new InvalidOperationException("Cannot cancel a completed registration.");
         }
 
+        var courseId = registration.CourseId;
+        var wasConfirmed = registration.Status == RegistrationStatus.Confirmed;
+
         registration.Status = RegistrationStatus.Cancelled;
         _unitOfWork.Registrations.Update(registration);
         await _unitOfWork.SaveChangesAsync();
+
+        // If a confirmed registration was cancelled, notify the next person on the waitlist
+        if (wasConfirmed)
+        {
+            await _waitlistService.NotifyNextStudentAsync(courseId);
+        }
+
         return true;
     }
 
diff --git a/api/CourseRegistration.Application/Services/WaitlistService.cs b/api/CourseRegistration.Application/Services/WaitlistService.cs
new file mode 100644
index 0000000..d8d75f2
--- /dev/null
+++ b/api/CourseRegistration.Application/Services/WaitlistService.cs
@@ -0,0 +1,297 @@
+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 waitlist operations
+/// </summary>
+public class WaitlistService : IWaitlistService
+{
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly IMapper _mapper;
+    private readonly INotificationService _notificationService;
+
+    /// <summary>
+    /// Initializes a new instance of the WaitlistService
+    /// </summary>
+    public WaitlistService(
+        IUnitOfWork unitOfWork, 
+        IMapper mapper,
+        INotificationService notificationService)
+    {
+        _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
+        _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
+        _notificationService = notificationService ?? throw new ArgumentNullException(nameof(notificationService));
+    }
+
+    /// <summary>
+    /// Adds a student to a course waitlist
+    /// </summary>
+    public async Task<WaitlistEntryDto> JoinWaitlistAsync(CreateWaitlistEntryDto createWaitlistEntryDto)
+    {
+        // Validate student exists
+        var student = await _unitOfWork.Students.GetByIdAsync(createWaitlistEntryDto.StudentId);
+        if (student == null)
+        {
+            throw new InvalidOperationException("Student not found.");
+        }
+
+        // Validate course exists
+        var course = await _unitOfWork.Courses.GetByIdAsync(createWaitlistEntryDto.CourseId);
+        if (course == null)
+        {
+            throw new InvalidOperationException("Course not found.");
+        }
+
+        // Check if course is active
+        if (!course.IsActive)
+        {
+            throw new InvalidOperationException("Cannot join waitlist for an inactive course.");
+        }
+
+        // Check if student is already registered for this course
+        var isRegistered = await _unitOfWork.Registrations.IsStudentRegisteredForCourseAsync(
+            createWaitlistEntryDto.StudentId, createWaitlistEntryDto.CourseId);
+        if (isRegistered)
+        {
+            throw new InvalidOperationException("Student is already registered for this course.");
+        }
+
+        // Check if student is already on the waitlist
+        var isOnWaitlist = await _unitOfWork.Waitlists.IsStudentOnWaitlistAsync(
+            createWaitlistEntryDto.StudentId, createWaitlistEntryDto.CourseId);
+        if (isOnWaitlist)
+        {
+            throw new InvalidOperationException("Student is already on the waitlist for this course.");
+        }
+
+        // Get next position in the waitlist
+        var nextPosition = await _unitOfWork.Waitlists.GetNextPositionAsync(createWaitlistEntryDto.CourseId);
+
+        // Create waitlist entry
+        var waitlistEntry = _mapper.Map<WaitlistEntry>(createWaitlistEntryDto);
+        waitlistEntry.Position = nextPosition;
+        waitlistEntry.JoinedAt = DateTime.UtcNow;
+        waitlistEntry.IsActive = true;
+
+        await _unitOfWork.Waitlists.AddAsync(waitlistEntry);
+        await _unitOfWork.SaveChangesAsync();
+
+        // Get the waitlist entry with related entities
+        var savedEntry = await _unitOfWork.Waitlists.GetWithDetailsAsync(waitlistEntry.WaitlistEntryId);
+        return _mapper.Map<WaitlistEntryDto>(savedEntry);
+    }
+
+    /// <summary>
+    /// Removes a student from a course waitlist
+    /// </summary>
+    public async Task<bool> LeaveWaitlistAsync(Guid waitlistEntryId)
+    {
+        var waitlistEntry = await _unitOfWork.Waitlists.GetByIdAsync(waitlistEntryId);
+        if (waitlistEntry == null || !waitlistEntry.IsActive)
+        {
+            return false;
+        }
+
+        var courseId = waitlistEntry.CourseId;
+        var position = waitlistEntry.Position;
+
+        // Mark as inactive instead of deleting
+        waitlistEntry.IsActive = false;
+        _unitOfWork.Waitlists.Update(waitlistEntry);
+        await _unitOfWork.SaveChangesAsync();
+
+        // Reorder remaining waitlist entries
+        await _unitOfWork.Waitlists.ReorderWaitlistAsync(courseId, position);
+
+        return true;
+    }
+
+    /// <summary>
+    /// Gets active waitlist entries for a course
+    /// </summary>
+    public async Task<IEnumerable<WaitlistEntryDto>> GetCourseWaitlistAsync(Guid courseId)
+    {
+        var waitlistEntries = await _unitOfWork.Waitlists.GetActiveWaitlistForCourseAsync(courseId);
+        return _mapper.Map<IEnumerable<WaitlistEntryDto>>(waitlistEntries);
+    }
+
+    /// <summary>
+    /// Gets a student's active waitlist entries
+    /// </summary>
+    public async Task<IEnumerable<WaitlistEntryDto>> GetStudentWaitlistsAsync(Guid studentId)
+    {
+        var waitlistEntries = await _unitOfWork.Waitlists.GetStudentActiveWaitlistEntriesAsync(studentId);
+        return _mapper.Map<IEnumerable<WaitlistEntryDto>>(waitlistEntries);
+    }
+
+    /// <summary>
+    /// Gets a specific waitlist entry by ID
+    /// </summary>
+    public async Task<WaitlistEntryDto?> GetWaitlistEntryAsync(Guid waitlistEntryId)
+    {
+        var waitlistEntry = await _unitOfWork.Waitlists.GetWithDetailsAsync(waitlistEntryId);
+        return waitlistEntry != null ? _mapper.Map<WaitlistEntryDto>(waitlistEntry) : null;
+    }
+
+    /// <summary>
+    /// Updates a waitlist entry (admin function)
+    /// </summary>
+    public async Task<WaitlistEntryDto?> UpdateWaitlistEntryAsync(Guid waitlistEntryId, UpdateWaitlistEntryDto updateDto)
+    {
+        var existingEntry = await _unitOfWork.Waitlists.GetWithDetailsAsync(waitlistEntryId);
+        if (existingEntry == null)
+        {
+            return null;
+        }
+
+        // Update only the fields that are provided
+        if (updateDto.NotificationPreference.HasValue)
+        {
+            existingEntry.NotificationPreference = updateDto.NotificationPreference.Value;
+        }
+
+        if (updateDto.Notes != null)
+        {
+            existingEntry.Notes = updateDto.Notes;
+        }
+
+        // Handle position change if provided (admin reordering)
+        if (updateDto.Position.HasValue && updateDto.Position.Value != existingEntry.Position)
+        {
+            var oldPosition = existingEntry.Position;
+            var newPosition = updateDto.Position.Value;
+
+            // Get all active waitlist entries for the course
+            var allEntries = await _unitOfWork.Waitlists.GetActiveWaitlistForCourseAsync(existingEntry.CourseId);
+            var entriesList = allEntries.ToList();
+
+            // Validate new position
+            if (newPosition < 1 || newPosition > entriesList.Count)
+            {
+                throw new InvalidOperationException("Invalid position specified.");
+            }
+
+            // Reorder entries
+            if (newPosition < oldPosition)
+            {
+                // Moving up in the list
+                foreach (var entry in entriesList.Where(e => e.Position >= newPosition && e.Position < oldPosition))
+                {
+                    entry.Position++;
+                }
+            }
+            else
+            {
+                // Moving down in the list
+                foreach (var entry in entriesList.Where(e => e.Position > oldPosition && e.Position <= newPosition))
+                {
+                    entry.Position--;
+                }
+            }
+
+            existingEntry.Position = newPosition;
+        }
+
+        _unitOfWork.Waitlists.Update(existingEntry);
+        await _unitOfWork.SaveChangesAsync();
+
+        return _mapper.Map<WaitlistEntryDto>(existingEntry);
+    }
+
+    /// <summary>
+    /// Notifies the next student on the waitlist when a spot becomes available
+    /// </summary>
+    public async Task NotifyNextStudentAsync(Guid courseId)
+    {
+        var waitlistEntries = await _unitOfWork.Waitlists.GetActiveWaitlistForCourseAsync(courseId);
+        var nextEntry = waitlistEntries.OrderBy(w => w.Position).FirstOrDefault();
+
+        if (nextEntry != null)
+        {
+            // Send notification based on preference
+            await _notificationService.SendWaitlistNotificationAsync(
+                nextEntry.Student.Email,
+                nextEntry.Student.FullName,
+                nextEntry.Course.CourseName,
+                nextEntry.Position,
+                nextEntry.NotificationPreference);
+
+            // Mark as notified
+            nextEntry.NotifiedAt = DateTime.UtcNow;
+            _unitOfWork.Waitlists.Update(nextEntry);
+            await _unitOfWork.SaveChangesAsync();
+        }
+    }
+
+    /// <summary>
+    /// Clears the entire waitlist for a course (admin function)
+    /// </summary>
+    public async Task<bool> ClearWaitlistAsync(Guid courseId)
+    {
+        var waitlistEntries = await _unitOfWork.Waitlists.GetActiveWaitlistForCourseAsync(courseId);
+        
+        foreach (var entry in waitlistEntries)
+        {
+            entry.IsActive = false;
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return true;
+    }
+
+    /// <summary>
+    /// Reorders waitlist entries (admin function)
+    /// </summary>
+    public async Task<bool> ReorderWaitlistAsync(Guid courseId, Dictionary<Guid, int> newPositions)
+    {
+        var waitlistEntries = await _unitOfWork.Waitlists.GetActiveWaitlistForCourseAsync(courseId);
+        var entriesList = waitlistEntries.ToList();
+
+        // Validate that all entries are included in the reorder
+        if (newPositions.Count != entriesList.Count)
+        {
+            throw new InvalidOperationException(
+                $"All waitlist entries must be included. Expected {entriesList.Count} positions but got {newPositions.Count}.");
+        }
+
+        // Validate that all entry IDs are present
+        var missingEntries = entriesList.Where(e => !newPositions.ContainsKey(e.WaitlistEntryId)).ToList();
+        if (missingEntries.Any())
+        {
+            throw new InvalidOperationException(
+                $"Missing position assignments for {missingEntries.Count} waitlist entry/entries.");
+        }
+
+        // Validate that all positions are unique and sequential
+        var positions = newPositions.Values.OrderBy(p => p).ToList();
+        for (int i = 0; i < positions.Count; i++)
+        {
+            if (positions[i] != i + 1)
+            {
+                throw new InvalidOperationException("Positions must be sequential starting from 1.");
+            }
+        }
+
+        // Update positions
+        foreach (var entry in entriesList)
+        {
+            entry.Position = newPositions[entry.WaitlistEntryId];
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return true;
+    }
+
+    /// <summary>
+    /// Checks if a student is on the waitlist for a course
+    /// </summary>
+    public async Task<bool> IsStudentOnWaitlistAsync(Guid studentId, Guid courseId)
+    {
+        return await _unitOfWork.Waitlists.IsStudentOnWaitlistAsync(studentId, courseId);
+    }
+}
diff --git a/api/CourseRegistration.Domain/Entities/Course.cs b/api/CourseRegistration.Domain/Entities/Course.cs
index dc3f941..9867c11 100644
--- a/api/CourseRegistration.Domain/Entities/Course.cs
+++ b/api/CourseRegistration.Domain/Entities/Course.cs
@@ -53,6 +53,12 @@ public class Course
     [MaxLength(100)]
     public string Schedule { get; set; } = string.Empty;
 
+    /// <summary>
+    /// Maximum number of students allowed to enroll in the course
+    /// </summary>
+    [Required]
+    public int MaxEnrollment { get; set; } = 30;
+
     /// <summary>
     /// Indicates if the course is active
     /// </summary>
@@ -73,9 +79,20 @@ public class Course
     /// </summary>
     public virtual ICollection<Registration> Registrations { get; set; } = new List<Registration>();
 
+    /// <summary>
+    /// Navigation property for course waitlist entries
+    /// </summary>
+    public virtual ICollection<WaitlistEntry> WaitlistEntries { get; set; } = new List<WaitlistEntry>();
+
     /// <summary>
     /// Computed property for current enrollment count
     /// </summary>
     [NotMapped]
     public int CurrentEnrollment => Registrations?.Count(r => r.Status == Enums.RegistrationStatus.Confirmed) ?? 0;
+
+    /// <summary>
+    /// Computed property to check if course is full
+    /// </summary>
+    [NotMapped]
+    public bool IsFull => CurrentEnrollment >= MaxEnrollment;
 }
\ No newline at end of file
diff --git a/api/CourseRegistration.Domain/Entities/Student.cs b/api/CourseRegistration.Domain/Entities/Student.cs
index ee4a5b1..1737c8e 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 waitlist entries
+    /// </summary>
+    public virtual ICollection<WaitlistEntry> WaitlistEntries { get; set; } = new List<WaitlistEntry>();
+
     /// <summary>
     /// Computed property for student's full name
     /// </summary>
diff --git a/api/CourseRegistration.Domain/Entities/WaitlistEntry.cs b/api/CourseRegistration.Domain/Entities/WaitlistEntry.cs
new file mode 100644
index 0000000..b5e9bc5
--- /dev/null
+++ b/api/CourseRegistration.Domain/Entities/WaitlistEntry.cs
@@ -0,0 +1,76 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using CourseRegistration.Domain.Enums;
+
+namespace CourseRegistration.Domain.Entities;
+
+/// <summary>
+/// Represents a student's entry on a course waitlist
+/// </summary>
+public class WaitlistEntry
+{
+    /// <summary>
+    /// Unique identifier for the waitlist entry
+    /// </summary>
+    [Key]
+    public Guid WaitlistEntryId { get; set; } = Guid.NewGuid();
+
+    /// <summary>
+    /// Foreign key to the student
+    /// </summary>
+    [Required]
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Foreign key to the course
+    /// </summary>
+    [Required]
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Date and time when the student joined the waitlist
+    /// </summary>
+    [Required]
+    public DateTime JoinedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Position in the waitlist (1-based)
+    /// </summary>
+    [Required]
+    public int Position { get; set; }
+
+    /// <summary>
+    /// Student's notification preference
+    /// </summary>
+    [Required]
+    public NotificationType NotificationPreference { get; set; } = NotificationType.Email;
+
+    /// <summary>
+    /// Indicates if the student is still active on the waitlist
+    /// </summary>
+    [Required]
+    public bool IsActive { get; set; } = true;
+
+    /// <summary>
+    /// Date and time when the student was notified about an available spot
+    /// </summary>
+    public DateTime? NotifiedAt { get; set; }
+
+    /// <summary>
+    /// Notes about the waitlist entry (e.g., admin comments)
+    /// </summary>
+    [MaxLength(500)]
+    public string? Notes { get; set; }
+
+    /// <summary>
+    /// Navigation property to the student
+    /// </summary>
+    [ForeignKey(nameof(StudentId))]
+    public virtual Student Student { get; set; } = null!;
+
+    /// <summary>
+    /// Navigation property to the course
+    /// </summary>
+    [ForeignKey(nameof(CourseId))]
+    public virtual Course Course { get; set; } = null!;
+}
diff --git a/api/CourseRegistration.Domain/Enums/NotificationType.cs b/api/CourseRegistration.Domain/Enums/NotificationType.cs
new file mode 100644
index 0000000..9edea25
--- /dev/null
+++ b/api/CourseRegistration.Domain/Enums/NotificationType.cs
@@ -0,0 +1,22 @@
+namespace CourseRegistration.Domain.Enums;
+
+/// <summary>
+/// Represents the type of notification preference for waitlist
+/// </summary>
+public enum NotificationType
+{
+    /// <summary>
+    /// Email notification
+    /// </summary>
+    Email = 0,
+
+    /// <summary>
+    /// In-app notification
+    /// </summary>
+    InApp = 1,
+
+    /// <summary>
+    /// Both email and in-app notification
+    /// </summary>
+    Both = 2
+}
diff --git a/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs b/api/CourseRegistration.Domain/Interfaces/IUnitOfWork.cs
index c56d8f4..476e553 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>
+    /// Waitlist repository
+    /// </summary>
+    IWaitlistRepository Waitlists { get; }
+
     /// <summary>
     /// Saves all changes made in this unit of work asynchronously
     /// </summary>
diff --git a/api/CourseRegistration.Domain/Interfaces/IWaitlistRepository.cs b/api/CourseRegistration.Domain/Interfaces/IWaitlistRepository.cs
new file mode 100644
index 0000000..812fe8d
--- /dev/null
+++ b/api/CourseRegistration.Domain/Interfaces/IWaitlistRepository.cs
@@ -0,0 +1,44 @@
+using CourseRegistration.Domain.Entities;
+
+namespace CourseRegistration.Domain.Interfaces;
+
+/// <summary>
+/// Repository interface for WaitlistEntry operations
+/// </summary>
+public interface IWaitlistRepository : IRepository<WaitlistEntry>
+{
+    /// <summary>
+    /// Gets active waitlist entries for a specific course, ordered by position
+    /// </summary>
+    Task<IEnumerable<WaitlistEntry>> GetActiveWaitlistForCourseAsync(Guid courseId);
+
+    /// <summary>
+    /// Gets a student's active waitlist entry for a specific course
+    /// </summary>
+    Task<WaitlistEntry?> GetActiveWaitlistEntryAsync(Guid studentId, Guid courseId);
+
+    /// <summary>
+    /// Gets all active waitlist entries for a student
+    /// </summary>
+    Task<IEnumerable<WaitlistEntry>> GetStudentActiveWaitlistEntriesAsync(Guid studentId);
+
+    /// <summary>
+    /// Checks if a student is on the active waitlist for a course
+    /// </summary>
+    Task<bool> IsStudentOnWaitlistAsync(Guid studentId, Guid courseId);
+
+    /// <summary>
+    /// Gets the next available position for a course waitlist
+    /// </summary>
+    Task<int> GetNextPositionAsync(Guid courseId);
+
+    /// <summary>
+    /// Gets waitlist entry with student and course details
+    /// </summary>
+    Task<WaitlistEntry?> GetWithDetailsAsync(Guid waitlistEntryId);
+
+    /// <summary>
+    /// Reorders waitlist positions after a student is removed
+    /// </summary>
+    Task ReorderWaitlistAsync(Guid courseId, int removedPosition);
+}
diff --git a/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs b/api/CourseRegistration.Infrastructure/Data/CourseRegistrationDbContext.cs
index 7491da8..62ff885 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>
+    /// WaitlistEntries DbSet
+    /// </summary>
+    public DbSet<WaitlistEntry> WaitlistEntries { get; set; } = null!;
+
     /// <summary>
     /// Configures the model relationships and constraints
     /// </summary>
@@ -58,6 +63,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                   .WithOne(r => r.Student)
                   .HasForeignKey(r => r.StudentId)
                   .OnDelete(DeleteBehavior.Cascade);
+
+            entity.HasMany(s => s.WaitlistEntries)
+                  .WithOne(w => w.Student)
+                  .HasForeignKey(w => w.StudentId)
+                  .OnDelete(DeleteBehavior.Cascade);
         });
 
         // Configure Course entity
@@ -70,6 +80,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             entity.Property(c => c.StartDate).IsRequired();
             entity.Property(c => c.EndDate).IsRequired();
             entity.Property(c => c.Schedule).IsRequired().HasMaxLength(100);
+            entity.Property(c => c.MaxEnrollment).IsRequired();
             entity.Property(c => c.IsActive).IsRequired();
             entity.Property(c => c.CreatedAt).IsRequired();
             entity.Property(c => c.UpdatedAt).IsRequired();
@@ -79,6 +90,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                   .WithOne(r => r.Course)
                   .HasForeignKey(r => r.CourseId)
                   .OnDelete(DeleteBehavior.Cascade);
+
+            entity.HasMany(c => c.WaitlistEntries)
+                  .WithOne(w => w.Course)
+                  .HasForeignKey(w => w.CourseId)
+                  .OnDelete(DeleteBehavior.Cascade);
         });
 
         // Configure Registration entity
@@ -108,6 +124,35 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                   .HasForeignKey(r => r.CourseId)
                   .OnDelete(DeleteBehavior.Cascade);
         });
+
+        // Configure WaitlistEntry entity
+        modelBuilder.Entity<WaitlistEntry>(entity =>
+        {
+            entity.HasKey(w => w.WaitlistEntryId);
+            entity.Property(w => w.StudentId).IsRequired();
+            entity.Property(w => w.CourseId).IsRequired();
+            entity.Property(w => w.JoinedAt).IsRequired();
+            entity.Property(w => w.Position).IsRequired();
+            entity.Property(w => w.NotificationPreference).IsRequired()
+                  .HasConversion<string>();
+            entity.Property(w => w.IsActive).IsRequired();
+            entity.Property(w => w.Notes).HasMaxLength(500);
+
+            // Create index for querying active waitlist entries
+            // Note: Only one active waitlist entry per student per course should exist
+            entity.HasIndex(w => new { w.StudentId, w.CourseId, w.IsActive });
+
+            // Configure relationships
+            entity.HasOne(w => w.Student)
+                  .WithMany(s => s.WaitlistEntries)
+                  .HasForeignKey(w => w.StudentId)
+                  .OnDelete(DeleteBehavior.Cascade);
+
+            entity.HasOne(w => w.Course)
+                  .WithMany(c => c.WaitlistEntries)
+                  .HasForeignKey(w => w.CourseId)
+                  .OnDelete(DeleteBehavior.Cascade);
+        });
     }
 
     /// <summary>
diff --git a/api/CourseRegistration.Infrastructure/Repositories/CourseRepository.cs b/api/CourseRegistration.Infrastructure/Repositories/CourseRepository.cs
index 985a879..90a7b3c 100644
--- a/api/CourseRegistration.Infrastructure/Repositories/CourseRepository.cs
+++ b/api/CourseRegistration.Infrastructure/Repositories/CourseRepository.cs
@@ -98,7 +98,7 @@ public async Task<IEnumerable<Course>> GetCoursesByInstructorAsync(string instru
     }
 
     /// <summary>
-    /// Override GetPagedAsync to only return active courses
+    /// Override GetPagedAsync to only return active courses with registrations
     /// </summary>
     public override async Task<IEnumerable<Course>> GetPagedAsync(int page, int pageSize)
     {
@@ -107,6 +107,8 @@ public override async Task<IEnumerable<Course>> GetPagedAsync(int page, int page
         if (pageSize > 100) pageSize = 100;
 
         return await _dbSet
+            .Include(c => c.Registrations)
+            .Include(c => c.WaitlistEntries)
             .Where(c => c.IsActive)
             .OrderBy(c => c.CourseName)
             .Skip((page - 1) * pageSize)
@@ -115,11 +117,13 @@ public override async Task<IEnumerable<Course>> GetPagedAsync(int page, int page
     }
 
     /// <summary>
-    /// Override GetByIdAsync to only return active courses
+    /// Override GetByIdAsync to only return active courses with registrations
     /// </summary>
     public override async Task<Course?> GetByIdAsync(Guid id)
     {
         return await _dbSet
+            .Include(c => c.Registrations)
+            .Include(c => c.WaitlistEntries)
             .Where(c => c.IsActive)
             .FirstOrDefaultAsync(c => c.CourseId == id);
     }
diff --git a/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs b/api/CourseRegistration.Infrastructure/Repositories/UnitOfWork.cs
index 63a4e8d..e57fa0e 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 IWaitlistRepository? _waitlists;
 
     /// <summary>
     /// Initializes a new instance of the UnitOfWork
@@ -64,6 +65,18 @@ public IRegistrationRepository Registrations
         }
     }
 
+    /// <summary>
+    /// Waitlist repository
+    /// </summary>
+    public IWaitlistRepository Waitlists
+    {
+        get
+        {
+            _waitlists ??= new WaitlistRepository(_context);
+            return _waitlists;
+        }
+    }
+
     /// <summary>
     /// Saves all changes made in this unit of work asynchronously
     /// </summary>
diff --git a/api/CourseRegistration.Infrastructure/Repositories/WaitlistRepository.cs b/api/CourseRegistration.Infrastructure/Repositories/WaitlistRepository.cs
new file mode 100644
index 0000000..bfcf4f4
--- /dev/null
+++ b/api/CourseRegistration.Infrastructure/Repositories/WaitlistRepository.cs
@@ -0,0 +1,110 @@
+using CourseRegistration.Domain.Entities;
+using CourseRegistration.Domain.Interfaces;
+using CourseRegistration.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace CourseRegistration.Infrastructure.Repositories;
+
+/// <summary>
+/// Repository implementation for WaitlistEntry operations
+/// </summary>
+public class WaitlistRepository : Repository<WaitlistEntry>, IWaitlistRepository
+{
+    /// <summary>
+    /// Initializes a new instance of the WaitlistRepository
+    /// </summary>
+    public WaitlistRepository(CourseRegistrationDbContext context) : base(context)
+    {
+    }
+
+    /// <summary>
+    /// Gets active waitlist entries for a specific course, ordered by position
+    /// </summary>
+    public async Task<IEnumerable<WaitlistEntry>> GetActiveWaitlistForCourseAsync(Guid courseId)
+    {
+        return await _context.WaitlistEntries
+            .Include(w => w.Student)
+            .Include(w => w.Course)
+            .Where(w => w.CourseId == courseId && w.IsActive)
+            .OrderBy(w => w.Position)
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// Gets a student's active waitlist entry for a specific course
+    /// </summary>
+    public async Task<WaitlistEntry?> GetActiveWaitlistEntryAsync(Guid studentId, Guid courseId)
+    {
+        return await _context.WaitlistEntries
+            .Include(w => w.Student)
+            .Include(w => w.Course)
+            .FirstOrDefaultAsync(w => w.StudentId == studentId && w.CourseId == courseId && w.IsActive);
+    }
+
+    /// <summary>
+    /// Gets all active waitlist entries for a student
+    /// </summary>
+    public async Task<IEnumerable<WaitlistEntry>> GetStudentActiveWaitlistEntriesAsync(Guid studentId)
+    {
+        return await _context.WaitlistEntries
+            .Include(w => w.Student)
+            .Include(w => w.Course)
+            .Where(w => w.StudentId == studentId && w.IsActive)
+            .OrderBy(w => w.JoinedAt)
+            .ToListAsync();
+    }
+
+    /// <summary>
+    /// Checks if a student is on the active waitlist for a course
+    /// </summary>
+    public async Task<bool> IsStudentOnWaitlistAsync(Guid studentId, Guid courseId)
+    {
+        return await _context.WaitlistEntries
+            .AnyAsync(w => w.StudentId == studentId && w.CourseId == courseId && w.IsActive);
+    }
+
+    /// <summary>
+    /// Gets the next available position for a course waitlist
+    /// </summary>
+    public async Task<int> GetNextPositionAsync(Guid courseId)
+    {
+        var activeEntries = await _context.WaitlistEntries
+            .Where(w => w.CourseId == courseId && w.IsActive)
+            .ToListAsync();
+
+        if (!activeEntries.Any())
+        {
+            return 1;
+        }
+
+        return activeEntries.Max(w => w.Position) + 1;
+    }
+
+    /// <summary>
+    /// Gets waitlist entry with student and course details
+    /// </summary>
+    public async Task<WaitlistEntry?> GetWithDetailsAsync(Guid waitlistEntryId)
+    {
+        return await _context.WaitlistEntries
+            .Include(w => w.Student)
+            .Include(w => w.Course)
+            .FirstOrDefaultAsync(w => w.WaitlistEntryId == waitlistEntryId);
+    }
+
+    /// <summary>
+    /// Reorders waitlist positions after a student is removed
+    /// </summary>
+    public async Task ReorderWaitlistAsync(Guid courseId, int removedPosition)
+    {
+        var entriesToUpdate = await _context.WaitlistEntries
+            .Where(w => w.CourseId == courseId && w.IsActive && w.Position > removedPosition)
+            .ToListAsync();
+
+        foreach (var entry in entriesToUpdate)
+        {
+            entry.Position--;
+        }
+
+        await _context.SaveChangesAsync();
+    }
+}