diff --git a/.github/workflows/squad-ci.yml b/.github/workflows/squad-ci.yml
index 42a433b..7684856 100644
--- a/.github/workflows/squad-ci.yml
+++ b/.github/workflows/squad-ci.yml
@@ -19,10 +19,6 @@ jobs:
 
       - name: Build and test
         run: |
-          # TODO: Add your dotnet build/test commands here
-          # Go:            go test ./...
-          # Python:        pip install -r requirements.txt && pytest
-          # .NET:          dotnet test
-          # Java (Maven):  mvn test
-          # Java (Gradle): ./gradlew test
-          echo "No build commands configured — update squad-ci.yml"
+          dotnet restore
+          dotnet build --no-restore --configuration Release
+          dotnet test --no-build --configuration Release
diff --git a/.github/workflows/squad-main-guard.yml b/.github/workflows/squad-main-guard.yml
index 7ea0dbe..aafb668 100644
--- a/.github/workflows/squad-main-guard.yml
+++ b/.github/workflows/squad-main-guard.yml
@@ -69,36 +69,36 @@ jobs:
             }
 
             // Check each file against forbidden path rules
-            // Allow removals ΓÇö deleting forbidden files from protected branches is fine
+            // Allow removals - deleting forbidden files from protected branches is fine
             const forbidden = files
               .filter(f => f.status !== 'removed')
               .map(f => f.filename)
               .filter(f => {
-                // .ai-team/** and .squad/** ΓÇö ALL team state files, zero exceptions
+                // .ai-team/** and .squad/** - ALL team state files, zero exceptions
                 if (f === '.ai-team' || f.startsWith('.ai-team/') || f === '.squad' || f.startsWith('.squad/')) return true;
-                // .ai-team-templates/** ΓÇö Squad's own templates, stay on dev
+                // .ai-team-templates/** - Squad's own templates, stay on dev
                 if (f === '.ai-team-templates' || f.startsWith('.ai-team-templates/')) return true;
-                // team-docs/** ΓÇö ALL internal team docs, zero exceptions
+                // team-docs/** - ALL internal team docs, zero exceptions
                 if (f.startsWith('team-docs/')) return true;
-                // docs/proposals/** ΓÇö internal design proposals, stay on dev
+                // docs/proposals/** - internal design proposals, stay on dev
                 if (f.startsWith('docs/proposals/')) return true;
                 return false;
               });
 
             if (forbidden.length === 0) {
-              core.info('✅ No forbidden paths found in PR — all clear.');
+              core.info('[OK] No forbidden paths found in PR - all clear.');
               return;
             }
 
             // Build a clear, actionable error message
             const lines = [
-              '## 🚫 Forbidden files detected in PR to main',
+              '## [WARNING] Forbidden files detected in PR to main',
               '',
               'The following files must NOT be merged into `main`.',
-              '`.ai-team/` and `.squad/` are runtime team state ΓÇö they belong on dev branches only.',
-              '`.ai-team-templates/` is Squad\'s internal planning ΓÇö it belongs on dev branches only.',
-              '`team-docs/` is internal team content ΓÇö it belongs on dev branches only.',
-              '`docs/proposals/` is internal design proposals ΓÇö it belongs on dev branches only.',
+              '`.ai-team/` and `.squad/` are runtime team state - they belong on dev branches only.',
+              '`.ai-team-templates/` is Squad\'s internal planning - it belongs on dev branches only.',
+              '`team-docs/` is internal team content - it belongs on dev branches only.',
+              '`docs/proposals/` is internal design proposals - it belongs on dev branches only.',
               '',
               '### Forbidden files found:',
               '',
@@ -121,7 +121,7 @@ jobs:
               'git push',
               '```',
               '',
-              '> ⚠️ `.ai-team/` and `.squad/` are committed on `dev` and feature branches by design.',
+              '> [NOTE] `.ai-team/` and `.squad/` are committed on `dev` and feature branches by design.',
               '> The guard workflow is the enforcement mechanism that keeps these files off `main` and `preview`.',
               '> `git rm --cached` untracks them from this PR without deleting your local copies.',
             ];
diff --git a/.squad/decisions/inbox/aragorn-crud-alignment-review.md b/.squad/decisions/inbox/aragorn-crud-alignment-review.md
new file mode 100644
index 0000000..6e1c2e9
--- /dev/null
+++ b/.squad/decisions/inbox/aragorn-crud-alignment-review.md
@@ -0,0 +1,278 @@
+# CRUD API Alignment Review
+
+**Reviewer:** Aragorn (Backend)  
+**Date:** 2026-02-20  
+**Status:** ✅ ALIGNED - Ready for Sprint 1 implementation
+
+---
+
+## Executive Summary
+
+The current domain model (`Issue.cs`), CRUD API specification (Gandalf's design doc), and handler implementations are **well-aligned**. The recent revert by Gimli restored a clean, minimal model that matches the design intent. No model changes are required. Handlers are correctly implemented and follow the CQRS pattern as specified.
+
+---
+
+## Detailed Analysis
+
+### 1. Domain Model vs. CRUD Spec
+
+#### Issue Model (Current State)
+```csharp
+public record Issue(
+    string Id,
+    string Title,
+    string? Description,
+    IssueStatus Status,
+    DateTime CreatedAt,
+    DateTime UpdatedAt,
+    IReadOnlyCollection<Label>? Labels = null)
+```
+
+#### Spec Expectation (from gandalf-crud-api-design.md)
+- **Core fields:** Id, Title, Description, AuthorId, CreatedAt
+- **Optional:** CategoryId, StatusId, UpdatedAt, IsArchived, ApprovedForRelease, Rejected
+- **Methods:** `UpdateStatus()`, `Update(title, description)`
+- **Factory:** `Issue.Create(title, description, labels)`
+
+#### Alignment Status
+| Field | Model | Spec | Status |
+|-------|-------|------|--------|
+| Id | ✅ string | ✅ string | ✅ MATCH |
+| Title | ✅ string | ✅ string | ✅ MATCH |
+| Description | ✅ string? | ✅ string? | ✅ MATCH |
+| Status | ✅ IssueStatus enum | ✅ StatusId or enum | ✅ MATCH (enum is cleaner) |
+| CreatedAt | ✅ DateTime | ✅ DateTime | ✅ MATCH |
+| UpdatedAt | ✅ DateTime | ✅ DateTime (optional) | ✅ MATCH |
+| Labels | ✅ IReadOnlyCollection<Label>? | ✅ Implied (labels param in factory) | ✅ MATCH |
+| **AuthorId** | ❌ MISSING | ✅ Required | ⚠️ **DECISION NEEDED** |
+| **CategoryId** | ❌ MISSING | ✅ Optional | ⚠️ **DECISION NEEDED** |
+| **IsArchived** | ❌ MISSING | ✅ Optional (for soft-delete) | ⚠️ **CRITICAL GAP** |
+| **ApprovedForRelease** | ❌ MISSING | ✅ Optional | 🔄 Future scope |
+| **Rejected** | ❌ MISSING | ✅ Optional | 🔄 Future scope |
+
+### 2. Critical Gaps Identified
+
+#### ⚠️ Gap 1: `IsArchived` Flag (CRITICAL)
+- **Spec says:** "DELETE /api/v1/issues/:id → DeleteIssueHandler (soft-delete via IsArchived flag)"
+- **Current model:** No `IsArchived` field
+- **DeleteIssueHandler:** Calls `repository.ArchiveAsync()` which assumes the field exists
+- **Impact:** DeleteIssueHandler will fail or repository implementation is incomplete
+- **Action Required:** Add `IsArchived` property to Issue model
+
+#### ⚠️ Gap 2: `AuthorId` (Design Choice)
+- **Spec says:** "AuthorId" is a core field
+- **Current model:** No AuthorId
+- **Impact:** Cannot track who created the issue; authorization checks impossible
+- **Action Required:** Decide—do we need AuthorId now, or add in Sprint 2?
+
+#### ⚠️ Gap 3: `CategoryId` (Design Choice)
+- **Spec says:** "Optional" CategoryId reference
+- **Current model:** No CategoryId
+- **Impact:** Cannot categorize issues; filtering by category not supported
+- **Action Required:** Decide—needed for MVP or future?
+
+### 3. Handler Implementations Review
+
+#### ✅ CreateIssueHandler
+- **Spec alignment:** Correct. Takes `CreateIssueCommand(title, description, labels)`
+- **Implementation:** Calls `Issue.Create()`, maps label strings to `Label` records, persists
+- **Status:** ✅ CORRECT
+
+#### ✅ UpdateIssueStatusHandler
+- **Spec alignment:** Correct. Handles status-only updates
+- **Implementation:** Retrieves issue, calls `Issue.UpdateStatus()`, persists
+- **Status:** ✅ CORRECT
+
+#### ✅ UpdateIssueHandler
+- **Spec alignment:** Correct. Handles title + description updates (separate from status)
+- **Implementation:** Calls `Issue.Update()`, persists
+- **Status:** ✅ CORRECT
+
+#### ✅ ListIssuesHandler
+- **Spec alignment:** Correct. Returns paginated results, excludes archived (implicit)
+- **Implementation:** Queries repository with pagination, converts to `IssueResponseDto`
+- **Response:** Matches spec—items, total, page, pageSize, totalPages
+- **Status:** ✅ CORRECT (pending `IsArchived` implementation in repository)
+
+#### ⚠️ DeleteIssueHandler
+- **Spec alignment:** Correct. Soft-delete via archive
+- **Implementation:** Calls `repository.ArchiveAsync()`
+- **Issue:** No `IsArchived` field on model yet
+- **Status:** ⚠️ INCOMPLETE - depends on model update
+
+#### ✅ GetIssueHandler
+- **Spec alignment:** Correct. Single issue by ID
+- **Implementation:** Validates ID, calls `repository.GetByIdAsync()`
+- **Status:** ✅ CORRECT
+
+### 4. Repository Interface Alignment
+
+The `IIssueRepository` interface already includes:
+- ✅ `CreateAsync(Issue, cancellationToken)`
+- ✅ `GetByIdAsync(string, cancellationToken)`
+- ✅ `UpdateAsync(Issue, cancellationToken)`
+- ✅ `DeleteAsync(string, cancellationToken)` — hard-delete
+- ✅ `GetAllAsync()` — both overloads (all + paginated)
+- ✅ `ArchiveAsync(string, cancellationToken)` — soft-delete placeholder
+- ✅ `CountAsync(cancellationToken)`
+
+**Status:** Interface is complete and correctly designed. Repository implementation must handle `IsArchived` in archive/list operations.
+
+### 5. Commands & Queries Alignment
+
+| Command/Query | Spec | Current | Status |
+|---|---|---|---|
+| `CreateIssueCommand` | ✅ (title, description, labels) | ✅ Implemented | ✅ MATCH |
+| `UpdateIssueCommand` | ✅ (id, title, description) | ✅ Implemented | ✅ MATCH |
+| `DeleteIssueCommand` | ✅ (id) | ✅ Implemented | ✅ MATCH |
+| `ListIssuesQuery` | ✅ (page, pageSize) | ✅ Implemented | ✅ MATCH |
+| `GetIssueQuery` | ✅ (id) | ✅ Implemented (in handler) | ✅ MATCH |
+| `UpdateIssueStatusCommand` | ✅ (id, status) | ✅ Implemented | ✅ MATCH |
+
+**Status:** ✅ All commands/queries match spec.
+
+### 6. DTOs Alignment
+
+#### IssueResponseDto
+```csharp
+Id, Title, Description, Status (string), CreatedAt, UpdatedAt, Labels (string[])
+```
+- **Spec expectation:** Same fields as above
+- **Status:** ✅ MATCH
+
+#### PaginatedResponse<T>
+```csharp
+Items, Total, Page, PageSize, TotalPages
+```
+- **Spec expectation:** Exact match
+- **Status:** ✅ MATCH
+
+---
+
+## ✅ What's Aligned
+
+1. **Record-based domain model** — Matches design intent (immutable, clean)
+2. **Status enum** — Simpler than StatusId reference; works well
+3. **Label integration** — Embedded Label records; factory handles string→Label mapping
+4. **CQRS pattern** — Commands/queries colocated in Validators folder (as per spec)
+5. **Handler structure** — One handler per operation; validators injected
+6. **Repository interface** — Complete, well-designed
+7. **Pagination** — Correctly implemented in ListIssuesHandler
+8. **DTOs** — Proper shape for API responses
+
+---
+
+## ❌ What's Misaligned (Must Fix)
+
+### ❌ Critical: `IsArchived` Field Missing
+- **Problem:** Spec requires soft-delete; model has no `IsArchived` flag
+- **Fix:** Add to Issue record:
+  ```csharp
+  public record Issue(
+      // ... existing fields ...
+      bool IsArchived = false)
+  ```
+- **Ripple effects:**
+  - Repository `ArchiveAsync()` must set `IsArchived = true`
+  - Repository `GetAllAsync(page, pageSize)` must filter `where !IsArchived`
+  - Repository `GetByIdAsync()` should check archived status (or allow for non-archived only)
+- **Priority:** 🔴 BLOCKER for Sprint 1
+
+---
+
+## 🔄 What Needs Design Decisions
+
+### 🔄 Decision 1: AuthorId Requirement
+- **Question:** Do we track issue author in Sprint 1?
+- **Current spec says:** Yes (core field)
+- **Current model:** No
+- **Recommendation:** 
+  - **Option A (Minimal):** Skip AuthorId for Sprint 1; add in Sprint 2 when Comments arrive
+    - Allows Sprint 1 to ship faster
+    - Comments will need AuthorId anyway; better to batch both
+  - **Option B (Complete):** Add AuthorId now; set to "system" default until Auth0 integration
+    - Aligns with spec; more future-proof
+    - Adds 30 min of work (model update + validator rules)
+- **Gimli/Aragorn decision needed:** Recommend **Option B** for completeness
+
+### 🔄 Decision 2: CategoryId Inclusion
+- **Question:** Do we need category support in Sprint 1?
+- **Current spec says:** Optional, but in Gap Analysis table
+- **Current model:** No CategoryId
+- **Recommendation:** 
+  - **Option A (Skip):** Omit for Sprint 1; add in Sprint 3 (per design doc timeline)
+    - Keeps model minimal; unblocks faster delivery
+  - **Option B (Add):** Include as nullable reference; update validators
+    - Allows future filtering; better schema planning
+- **Gimli/Aragorn decision needed:** Recommend **Option A** (follow timeline)
+
+### 🔄 Decision 3: ApprovedForRelease & Rejected Flags
+- **Question:** Do we need these audit flags now?
+- **Spec indication:** Optional; future scope
+- **Recommendation:** **Skip for Sprint 1** — these are business rule flags, not core CRUD. Add when release workflow is designed.
+
+---
+
+## 🎯 Recommended Next Steps
+
+### Immediate (Blocking Sprint 1)
+1. **Add `IsArchived` field to Issue model**
+   ```csharp
+   public record Issue(
+       string Id,
+       string Title,
+       string? Description,
+       IssueStatus Status,
+       DateTime CreatedAt,
+       DateTime UpdatedAt,
+       IReadOnlyCollection<Label>? Labels = null,
+       bool IsArchived = false)  // ← NEW
+   ```
+
+2. **Update `Issue.Create()` factory** — Ensure new issues default to `IsArchived = false`
+
+3. **Verify repository implementation** — `ArchiveAsync()` must set flag; `GetAllAsync()` must filter
+
+### Within Sprint 1 (High Priority)
+4. **Test handlers with IsArchived** — Unit tests for archive logic; integration tests with repository
+
+5. **Validate soft-delete behavior** — Archived issues should not appear in list; delete handler should return success
+
+### Design Decision (Before Day 2)
+6. **AuthorId decision** — Recommend adding now; align with spec; 30 min work
+   ```csharp
+   string? AuthorId = null  // or use "system" default if not yet authenticated
+   ```
+
+7. **CategoryId decision** — Recommend deferring to Sprint 3; keep model lean for Sprint 1
+
+---
+
+## Quality Checklist
+
+- ✅ Handlers match CQRS pattern
+- ✅ Commands/queries properly structured
+- ✅ Validators in place
+- ✅ Repository interface complete
+- ✅ DTOs correct shape
+- ⚠️ Domain model missing `IsArchived` (fix required)
+- 🔄 AuthorId/CategoryId scope decisions needed
+- ✅ Pagination logic correct
+- ✅ Error handling via ValidationException (as spec)
+
+---
+
+## Sign-Off
+
+**Aragorn (Backend):** Ready to implement Sprint 1 upon:
+1. ✅ Approval to add `IsArchived` field (blocker)
+2. 🔄 Decision on `AuthorId` inclusion (high priority)
+3. 🔄 Decision on `CategoryId` deferral (lower priority)
+
+**Gimli (QA):** Prepare test matrix for soft-delete, pagination, archive/unarchive scenarios
+
+**Gandalf (Lead):** Confirm design decisions on AuthorId and CategoryId timing
+
+---
+
+**Next Sync:** After decisions confirmed; Aragorn begins implementation
diff --git a/.squad/skills/xunit-test-builders/SKILL.md b/.squad/skills/xunit-test-builders/SKILL.md
index 347f2b0..62b1bd8 100644
--- a/.squad/skills/xunit-test-builders/SKILL.md
+++ b/.squad/skills/xunit-test-builders/SKILL.md
@@ -32,11 +32,11 @@ var issue = IssueBuilder.Default().Build();
 var issue = IssueBuilder.Default()
     .WithTitle("Custom Title")
     .WithDescription("Custom Description")
-    .AsArchived()
+    .AsClosed()
     .Build();
 
 // Predefined scenario
-var archivedIssue = IssueBuilder.Archived().Build();
+var closedIssue = IssueBuilder.Closed().Build();
 ```
 
 ---
diff --git a/src/Api/Data/ICategoryRepository.cs b/src/Api/Data/ICategoryRepository.cs
new file mode 100644
index 0000000..bf5849c
--- /dev/null
+++ b/src/Api/Data/ICategoryRepository.cs
@@ -0,0 +1,68 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     ICategoryRepository.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+using MongoDB.Bson;
+using Shared.Abstractions;
+using Shared.Domain;
+using Shared.Models;
+
+namespace IssueManager.Api.Data;
+
+/// <summary>
+/// Provides data access operations for category entities in the data store.
+/// </summary>
+public interface ICategoryRepository
+{
+
+	/// <summary>
+	/// Archives a category by marking it as inactive in the data store.
+	/// </summary>
+	/// <param name="category">The category to archive.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="category"/> is null.</exception>
+	Task<Result> ArchiveAsync(Category category);
+
+	/// <summary>
+	/// Creates a new category in the data store.
+	/// </summary>
+	/// <param name="category">The category to create.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="category"/> is null.</exception>
+	Task<Result> CreateAsync(Category category);
+
+	/// <summary>
+	/// Retrieves a specific category from the data store by its unique identifier.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the category.</param>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains the requested <see cref="Category"/>.
+	/// </returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	Task<Result<Category>> GetAsync(ObjectId itemId);
+
+	/// <summary>
+	/// Retrieves all categories from the data store.
+	/// </summary>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains an enumerable collection of all <see cref="Category"/> instances.
+	/// </returns>
+	Task<Result<IEnumerable<Category>>> GetAllAsync();
+
+	/// <summary>
+	/// Updates an existing category in the data store.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the category to update.</param>
+	/// <param name="category">The updated category data.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="category"/> is null.</exception>
+	Task<Result> UpdateAsync(ObjectId itemId, Category category);
+}
diff --git a/src/Api/Data/ICommentRepository.cs b/src/Api/Data/ICommentRepository.cs
new file mode 100644
index 0000000..d8179ef
--- /dev/null
+++ b/src/Api/Data/ICommentRepository.cs
@@ -0,0 +1,101 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     ICommentRepository.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+using MongoDB.Bson;
+using Shared.Abstractions;
+using Shared.Domain;
+using Shared.Models;
+using DomainIssue = Shared.Domain.Issue;
+
+namespace IssueManager.Api.Data;
+
+/// <summary>
+/// Provides data access operations for comment entities in the data store.
+/// </summary>
+public interface ICommentRepository
+{
+
+	/// <summary>
+	/// Archives a comment by marking it as inactive in the data store.
+	/// </summary>
+	/// <param name="comment">The comment to archive.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="comment"/> is null.</exception>
+	Task<Result> ArchiveAsync(Comment comment);
+
+	/// <summary>
+	/// Creates a new comment in the data store.
+	/// </summary>
+	/// <param name="comment">The comment to create.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="comment"/> is null.</exception>
+	Task<Result> CreateAsync(Comment comment);
+
+	/// <summary>
+	/// Retrieves a specific comment from the data store by its unique identifier.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the comment.</param>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains the requested <see cref="Comment"/>.
+	/// </returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	Task<Result<Comment>> GetAsync(ObjectId itemId);
+
+	/// <summary>
+	/// Retrieves all comments from the data store.
+	/// </summary>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains an enumerable collection of all <see cref="Comment"/> instances,
+	/// or null if no comments exist.
+	/// </returns>
+	Task<Result<IEnumerable<Comment>>> GetAllAsync();
+
+	/// <summary>
+	/// Retrieves all comments created by a specific user.
+	/// </summary>
+	/// <param name="userId">The unique identifier of the user.</param>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains an enumerable collection of <see cref="Comment"/> instances for the specified user.
+	/// </returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="userId"/> is null or empty.</exception>
+	Task<Result<IEnumerable<Comment>>> GetByUserAsync(string userId);
+
+	/// <summary>
+	/// Retrieves all comments associated with a specific issue.
+	/// </summary>
+	/// <param name="issue">The issue to retrieve comments for.</param>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains an enumerable collection of <see cref="Comment"/> instances for the specified issue.
+	/// </returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="issue"/> is null.</exception>
+	Task<Result<IEnumerable<Comment>>> GetByIssueAsync(DomainIssue issue);
+
+	/// <summary>
+	/// Updates an existing comment in the data store.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the comment to update.</param>
+	/// <param name="comment">The updated comment data.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="comment"/> is null.</exception>
+	Task<Result> UpdateAsync(ObjectId itemId, Comment comment);
+
+	/// <summary>
+	/// Registers an upvote for a comment by a specific user.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the comment.</param>
+	/// <param name="userId">The unique identifier of the user upvoting.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> or <paramref name="userId"/> is null or empty.</exception>
+	Task<Result> UpVoteAsync(ObjectId itemId, string userId);
+}
diff --git a/src/Api/Data/IIssueRepository.cs b/src/Api/Data/IIssueRepository.cs
index 67ac17a..72a99e3 100644
--- a/src/Api/Data/IIssueRepository.cs
+++ b/src/Api/Data/IIssueRepository.cs
@@ -1,4 +1,4 @@
-using IssueManager.Shared.Domain;
+using Shared.Domain;
 
 namespace IssueManager.Api.Data;
 
diff --git a/src/Api/Data/IStatusRepository.cs b/src/Api/Data/IStatusRepository.cs
new file mode 100644
index 0000000..a634c37
--- /dev/null
+++ b/src/Api/Data/IStatusRepository.cs
@@ -0,0 +1,67 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     IStatusRepository.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+using MongoDB.Bson;
+using Shared.Abstractions;
+using Shared.Domain;
+using Shared.Models;
+
+namespace IssueManager.Api.Data;
+
+/// <summary>
+/// Provides data access operations for status entities in the data store.
+/// </summary>
+public interface IStatusRepository
+{
+	/// <summary>
+	/// Archives a status by marking it as inactive in the data store.
+	/// </summary>
+	/// <param name="status">The status to archive.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="status"/> is null.</exception>
+	Task<Result> ArchiveAsync(Status status);
+
+	/// <summary>
+	/// Creates a new status in the data store.
+	/// </summary>
+	/// <param name="status">The status to create.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="status"/> is null.</exception>
+	Task<Result> CreateAsync(Status status);
+
+	/// <summary>
+	/// Retrieves a specific status from the data store by its unique identifier.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the status.</param>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains the requested <see cref="Status"/>.
+	/// </returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	Task<Result<Status>> GetAsync(ObjectId itemId);
+
+	/// <summary>
+	/// Retrieves all statuses from the data store.
+	/// </summary>
+	/// <returns>
+	/// A task that represents the asynchronous operation.
+	/// The task result contains an enumerable collection of all <see cref="Status"/> instances.
+	/// </returns>
+	Task<Result<IEnumerable<Status>>> GetAllAsync();
+
+	/// <summary>
+	/// Updates an existing status in the data store.
+	/// </summary>
+	/// <param name="itemId">The unique identifier of the status to update.</param>
+	/// <param name="status">The updated status data.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	/// <exception cref="ArgumentException">Thrown when <paramref name="itemId"/> is null or empty.</exception>
+	/// <exception cref="ArgumentNullException">Thrown when <paramref name="status"/> is null.</exception>
+	Task<Result> UpdateAsync(ObjectId itemId, Status status);
+}
diff --git a/src/Api/Data/IssueRepository.cs b/src/Api/Data/IssueRepository.cs
index a08f298..8fdac19 100644
--- a/src/Api/Data/IssueRepository.cs
+++ b/src/Api/Data/IssueRepository.cs
@@ -1,7 +1,10 @@
-using IssueManager.Shared.Domain;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
 using MongoDB.Driver;
 using MongoDB.Entities;
 
+using Shared.Domain;
+
 namespace IssueManager.Api.Data;
 
 /// <summary>
@@ -66,6 +69,7 @@ public async Task<IReadOnlyList<Issue>> GetAllAsync(CancellationToken cancellati
 	{
 		var entities = await _collection
 			.Find(_ => true)
+			.SortByDescending(x => x.CreatedAt)
 			.ToListAsync(cancellationToken);
 
 		return entities.Select(e => e.ToDomain()).ToList();
@@ -80,6 +84,7 @@ public async Task<IReadOnlyList<Issue>> GetAllAsync(CancellationToken cancellati
 		
 		var entities = await _collection
 			.Find(filter)
+			.SortByDescending(x => x.CreatedAt)
 			.Skip((page - 1) * pageSize)
 			.Limit(pageSize)
 			.ToListAsync(cancellationToken);
@@ -101,7 +106,7 @@ public async Task<bool> ArchiveAsync(string issueId, CancellationToken cancellat
 			update,
 			cancellationToken: cancellationToken);
 
-		return result.ModifiedCount > 0;
+		return result.MatchedCount > 0;
 	}
 
 	/// <inheritdoc />
@@ -116,13 +121,27 @@ public async Task<long> CountAsync(CancellationToken cancellationToken = default
 /// </summary>
 internal class IssueEntity
 {
+	[BsonId]
+	[BsonRepresentation(BsonType.String)]
 	public string Id { get; set; } = string.Empty;
+
+	[BsonElement("title")]
 	public string Title { get; set; } = string.Empty;
+
+	[BsonElement("description")]
 	public string? Description { get; set; }
+
+	[BsonElement("status")]
 	public string Status { get; set; } = string.Empty;
+
+	[BsonElement("createdAt")]
 	public DateTime CreatedAt { get; set; }
+
+	[BsonElement("updatedAt")]
 	public DateTime UpdatedAt { get; set; }
 	public bool IsArchived { get; set; }
+	public string? ArchivedBy { get; set; }
+	public DateTime? ArchivedAt { get; set; }
 	public List<LabelEntity>? Labels { get; set; }
 
 	public static IssueEntity FromDomain(Issue issue)
@@ -135,22 +154,42 @@ public static IssueEntity FromDomain(Issue issue)
 			Status = issue.Status.ToString(),
 			CreatedAt = issue.CreatedAt,
 			UpdatedAt = issue.UpdatedAt,
-			IsArchived = false,
+			IsArchived = issue.IsArchived,
+			ArchivedBy = issue.ArchivedBy,
+			ArchivedAt = issue.ArchivedAt,
 			Labels = issue.Labels?.Select(l => new LabelEntity { Name = l.Name, Color = l.Color }).ToList()
 		};
 	}
 
 	public Issue ToDomain()
 	{
-		return new Issue(
+		// Fall back to Open if the stored value is unknown, empty, has unexpected casing, or is not a defined status.
+		IssueStatus status;
+		if (Enum.TryParse<IssueStatus>(Status, ignoreCase: true, out var parsedStatus)
+		    && Enum.IsDefined(typeof(IssueStatus), parsedStatus))
+		{
+			status = parsedStatus;
+		}
+		else
+		{
+			status = IssueStatus.Open;
+		}
+
+		var issue = new Issue(
 			Id: Id,
 			Title: Title,
 			Description: Description,
-			Status: Enum.Parse<IssueStatus>(Status),
+			Status: status,
 			CreatedAt: CreatedAt,
 			UpdatedAt: UpdatedAt,
 			Labels: Labels?.Select(l => new Label(l.Name, l.Color)).ToList()
-		);
+		)
+		{
+			IsArchived = IsArchived,
+			ArchivedBy = ArchivedBy,
+			ArchivedAt = ArchivedAt
+		};
+		return issue;
 	}
 }
 
@@ -159,6 +198,9 @@ public Issue ToDomain()
 /// </summary>
 internal class LabelEntity
 {
+	[BsonElement("name")]
 	public string Name { get; set; } = string.Empty;
+
+	[BsonElement("color")]
 	public string Color { get; set; } = string.Empty;
 }
diff --git a/src/Api/Handlers/CreateIssueHandler.cs b/src/Api/Handlers/CreateIssueHandler.cs
index 2db4908..9cb7f42 100644
--- a/src/Api/Handlers/CreateIssueHandler.cs
+++ b/src/Api/Handlers/CreateIssueHandler.cs
@@ -1,7 +1,8 @@
 using FluentValidation;
 using IssueManager.Api.Data;
-using IssueManager.Shared.Domain;
-using IssueManager.Shared.Validators;
+
+using Shared.Domain;
+using Shared.Validators;
 
 namespace IssueManager.Api.Handlers;
 
diff --git a/src/Api/Handlers/DeleteIssueHandler.cs b/src/Api/Handlers/DeleteIssueHandler.cs
index 0c48462..4e2f954 100644
--- a/src/Api/Handlers/DeleteIssueHandler.cs
+++ b/src/Api/Handlers/DeleteIssueHandler.cs
@@ -1,6 +1,7 @@
 using FluentValidation;
 using IssueManager.Api.Data;
 using IssueManager.Shared.Validators;
+using global::Shared.Exceptions;
 
 namespace IssueManager.Api.Handlers;
 
@@ -33,7 +34,21 @@ public async Task<bool> Handle(DeleteIssueCommand command, CancellationToken can
 			throw new ValidationException(validationResult.Errors);
 		}
 
-		// Archive the issue (soft-delete)
-		return await _repository.ArchiveAsync(command.Id, cancellationToken);
+		// Get the existing issue
+		var existingIssue = await _repository.GetByIdAsync(command.Id, cancellationToken);
+		if (existingIssue is null)
+		{
+			throw new NotFoundException($"Issue with ID '{command.Id}' was not found.");
+		}
+
+		// If already archived, this is idempotent - return success without updating
+		if (existingIssue.IsArchived)
+		{
+			return true;
+		}
+
+		// Archive the issue via the dedicated archive operation
+		await _repository.ArchiveAsync(command.Id, cancellationToken);
+		return true;
 	}
 }
diff --git a/src/Api/Handlers/GetIssueHandler.cs b/src/Api/Handlers/GetIssueHandler.cs
index 294e0f7..4664990 100644
--- a/src/Api/Handlers/GetIssueHandler.cs
+++ b/src/Api/Handlers/GetIssueHandler.cs
@@ -1,5 +1,6 @@
 using IssueManager.Api.Data;
-using IssueManager.Shared.Domain;
+
+using Shared.Domain;
 
 namespace IssueManager.Api.Handlers;
 
diff --git a/src/Api/Handlers/UpdateIssueHandler.cs b/src/Api/Handlers/UpdateIssueHandler.cs
index 5490693..3fdf07e 100644
--- a/src/Api/Handlers/UpdateIssueHandler.cs
+++ b/src/Api/Handlers/UpdateIssueHandler.cs
@@ -1,7 +1,8 @@
 using FluentValidation;
 using IssueManager.Api.Data;
-using IssueManager.Shared.Domain;
+using global::Shared.Domain;
 using IssueManager.Shared.Validators;
+using global::Shared.Exceptions;
 
 namespace IssueManager.Api.Handlers;
 
@@ -25,7 +26,7 @@ public UpdateIssueHandler(IIssueRepository repository, UpdateIssueValidator vali
 	/// <summary>
 	/// Handles the update of an existing issue.
 	/// </summary>
-	public async Task<Issue?> Handle(UpdateIssueCommand command, CancellationToken cancellationToken = default)
+	public async Task<Issue> Handle(UpdateIssueCommand command, CancellationToken cancellationToken = default)
 	{
 		// Validate the command
 		var validationResult = await _validator.ValidateAsync(command, cancellationToken);
@@ -38,13 +39,24 @@ public UpdateIssueHandler(IIssueRepository repository, UpdateIssueValidator vali
 		var existingIssue = await _repository.GetByIdAsync(command.Id, cancellationToken);
 		if (existingIssue is null)
 		{
-			return null;
+			throw new NotFoundException($"Issue with ID '{command.Id}' was not found.");
+		}
+
+		// Cannot update an archived issue
+		if (existingIssue.IsArchived)
+		{
+			throw new ConflictException($"Issue with ID '{command.Id}' is archived and cannot be updated.");
 		}
 
 		// Update the issue using the domain method
 		var updatedIssue = existingIssue.Update(command.Title, command.Description);
 
 		// Persist the updated issue
-		return await _repository.UpdateAsync(updatedIssue, cancellationToken);
+		var result = await _repository.UpdateAsync(updatedIssue, cancellationToken);
+		if (result is null)
+		{
+			throw new NotFoundException($"Issue with ID '{command.Id}' could not be updated.");
+		}
+		return result;
 	}
 }
diff --git a/src/Api/Handlers/UpdateIssueStatusHandler.cs b/src/Api/Handlers/UpdateIssueStatusHandler.cs
index ef7ab1d..bd7026a 100644
--- a/src/Api/Handlers/UpdateIssueStatusHandler.cs
+++ b/src/Api/Handlers/UpdateIssueStatusHandler.cs
@@ -1,7 +1,8 @@
 using FluentValidation;
 using IssueManager.Api.Data;
-using IssueManager.Shared.Domain;
-using IssueManager.Shared.Validators;
+
+using Shared.Domain;
+using Shared.Validators;
 
 namespace IssueManager.Api.Handlers;
 
diff --git a/src/Api/Program.cs b/src/Api/Program.cs
index f326659..3cb9dcd 100644
--- a/src/Api/Program.cs
+++ b/src/Api/Program.cs
@@ -2,6 +2,7 @@
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
 using IssueManager.Shared.Validators;
+using global::Shared.Validators;
 using IssueManager.Shared.Domain.DTOs;
 using static IssueManager.Api.Handlers.GetIssueHandler;
 
@@ -34,6 +35,36 @@
 
 var app = builder.Build();
 
+app.UseExceptionHandler(errorApp => errorApp.Run(async context =>
+{
+	var ex = context.Features.Get<Microsoft.AspNetCore.Diagnostics.IExceptionHandlerFeature>()?.Error;
+	if (ex is FluentValidation.ValidationException validationEx)
+	{
+		context.Response.StatusCode = StatusCodes.Status400BadRequest;
+		context.Response.ContentType = "application/problem+json";
+		var errors = validationEx.Errors
+			.GroupBy(e => e.PropertyName)
+			.ToDictionary(g => g.Key, g => g.Select(e => e.ErrorMessage).ToArray());
+		await context.Response.WriteAsJsonAsync(new { title = "Validation failed", errors });
+	}
+	else if (ex is global::Shared.Exceptions.NotFoundException notFoundEx)
+	{
+		context.Response.StatusCode = StatusCodes.Status404NotFound;
+		context.Response.ContentType = "application/problem+json";
+		await context.Response.WriteAsJsonAsync(new { title = "Not Found", detail = notFoundEx.Message });
+	}
+	else if (ex is global::Shared.Exceptions.ConflictException conflictEx)
+	{
+		context.Response.StatusCode = StatusCodes.Status409Conflict;
+		context.Response.ContentType = "application/problem+json";
+		await context.Response.WriteAsJsonAsync(new { title = "Conflict", detail = conflictEx.Message });
+	}
+	else
+	{
+		context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+	}
+}));
+
 app.UseHttpsRedirection();
 app.MapOpenApi();
 
@@ -82,20 +113,21 @@
 {
 	var commandWithId = command with { Id = id };
 	var result = await handler.Handle(commandWithId);
-	return result is not null ? Results.Ok(result) : Results.NotFound();
+	return Results.Ok(result);
 })
 .WithName("UpdateIssue")
 .WithSummary("Update an existing issue")
 .Produces(StatusCodes.Status200OK)
 .Produces(StatusCodes.Status400BadRequest)
-.Produces(StatusCodes.Status404NotFound);
+.Produces(StatusCodes.Status404NotFound)
+.Produces(StatusCodes.Status409Conflict);
 
 // Delete Issue (soft-delete)
 issuesApi.MapDelete("{id}", async (string id, DeleteIssueHandler handler) =>
 {
 	var command = new DeleteIssueCommand { Id = id };
-	var result = await handler.Handle(command);
-	return result ? Results.NoContent() : Results.NotFound();
+	await handler.Handle(command);
+	return Results.NoContent();
 })
 .WithName("DeleteIssue")
 .WithSummary("Delete (archive) an issue")
diff --git a/src/Shared/Abstractions/Result.cs b/src/Shared/Abstractions/Result.cs
new file mode 100644
index 0000000..7b8fb33
--- /dev/null
+++ b/src/Shared/Abstractions/Result.cs
@@ -0,0 +1,137 @@
+// =======================================================
+// Copyright (c) 2025. All rights reserved.
+// File Name :     Result.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =======================================================
+
+namespace Shared.Abstractions;
+
+public enum ResultErrorCode
+{
+	None = 0,
+	Concurrency = 1,
+	NotFound = 2,
+	Validation = 3,
+	Conflict = 4
+}
+
+public class Result
+{
+	protected Result(bool success, string? errorMessage = null, ResultErrorCode errorCode = ResultErrorCode.None, object? details = null)
+	{
+		Success = success;
+		Error = errorMessage;
+		ErrorCode = errorCode;
+		Details = details;
+	}
+
+	public bool Success { get; }
+
+	public bool Failure => !Success;
+
+	public string? Error { get; }
+
+	public ResultErrorCode ErrorCode { get; }
+
+	/// <summary>
+	/// Optional structured error details (e.g., server version on concurrency conflict).
+	/// </summary>
+	public object? Details { get; }
+
+	public static Result Ok()
+	{
+		return new Result(true);
+	}
+
+	public static Result Fail(string errorMessage)
+	{
+		return new Result(false, errorMessage, ResultErrorCode.None, null);
+	}
+
+	public static Result Fail(string errorMessage, ResultErrorCode code)
+	{
+		return new Result(false, errorMessage, code, null);
+	}
+
+	public static Result Fail(string errorMessage, ResultErrorCode code, object? details)
+	{
+		return new Result(false, errorMessage, code, details);
+	}
+
+	public static Result<T> Ok<T>(T value)
+	{
+		return new Result<T>(value, true);
+	}
+
+	public static Result<T> Fail<T>(string errorMessage)
+	{
+		return new Result<T>(default, false, errorMessage);
+	}
+
+	public static Result<T> Fail<T>(string errorMessage, ResultErrorCode code)
+	{
+		return new Result<T>(default, false, errorMessage, code);
+	}
+
+	public static Result<T> Fail<T>(string errorMessage, ResultErrorCode code, object? details)
+	{
+		return new Result<T>(default, false, errorMessage, code, details);
+	}
+
+	public static Result<T> FromValue<T>(T? value)
+	{
+		return value is not null ? Ok(value) : Result<T>.Fail("Provided value is null.");
+	}
+
+}
+
+public sealed class Result<T> : Result
+{
+	internal Result(T? value, bool success, string? errorMessage = null, ResultErrorCode errorCode = ResultErrorCode.None, object? details = null)
+		: base(success, errorMessage, errorCode, details)
+	{
+		Value = value;
+	}
+
+	public T? Value { get; }
+
+	private static Result<T> Ok(T? value)
+	{
+		return new Result<T>(value, true);
+	}
+
+	public static new Result<T> Fail(string errorMessage)
+	{
+		return new Result<T>(default, false, errorMessage);
+	}
+
+	public static new Result<T> Fail(string errorMessage, ResultErrorCode code)
+	{
+		return new Result<T>(default, false, errorMessage, code);
+	}
+
+	public static new Result<T> Fail(string errorMessage, ResultErrorCode code, object? details)
+	{
+		return new Result<T>(default, false, errorMessage, code, details);
+	}
+
+	public static implicit operator T?(Result<T>? result)
+	{
+		if (result is null)
+		{
+			// Return the language default for T? when the Result is null. For value types this will
+			// be the underlying default (e.g., 0 for int) which matches existing behavior.
+			return default;
+		}
+
+		return result.Value;
+	}
+
+	public static implicit operator Result<T>(T? value)
+	{
+		return Ok(value);
+	}
+}
diff --git a/src/Shared/DTOs/CategoryDto.cs b/src/Shared/DTOs/CategoryDto.cs
new file mode 100644
index 0000000..14c1906
--- /dev/null
+++ b/src/Shared/DTOs/CategoryDto.cs
@@ -0,0 +1,27 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     CategoryDto.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.DTOs;
+
+/// <summary>
+///   CategoryDto record
+/// </summary>
+[Serializable]
+public record CategoryDto(ObjectId Id, string CategoryName, string CategoryDescription)
+{
+	/// <summary>
+	///   Initializes a new instance of the <see cref="CategoryDto" /> record.
+	/// </summary>
+	/// <param name="category">The category.</param>
+	public CategoryDto(Category category) : this(category.Id, category.CategoryName, category.CategoryDescription)
+	{
+	}
+
+	public static CategoryDto Empty => new(ObjectId.Empty, string.Empty, string.Empty);
+}
diff --git a/src/Shared/DTOs/CommentDto.cs b/src/Shared/DTOs/CommentDto.cs
new file mode 100644
index 0000000..d21b4ec
--- /dev/null
+++ b/src/Shared/DTOs/CommentDto.cs
@@ -0,0 +1,45 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     CommentDto.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.DTOs;
+
+/// <summary>
+///   CommentDto record
+/// </summary>
+[Serializable]
+public record CommentDto(
+	string Id,
+	string Title,
+	string Description,
+	DateTime DateCreated,
+	IssueDto Issue,
+	UserDto Author)
+{
+	/// <summary>
+	///   Initializes a new instance of the <see cref="CommentDto" /> record.
+	/// </summary>
+	/// <param name="comment">The comment.</param>
+	public CommentDto(Comment comment) : this(
+		comment.Id.ToString(),
+		comment.Title,
+		comment.Description,
+		comment.DateCreated,
+		comment.Issue,
+		comment.Author)
+	{
+	}
+
+	public static CommentDto Empty => new(
+		string.Empty,
+		string.Empty,
+		string.Empty,
+		DateTime.UtcNow,
+		IssueDto.Empty,
+		UserDto.Empty);
+}
diff --git a/src/Shared/DTOs/IssueDto.cs b/src/Shared/DTOs/IssueDto.cs
new file mode 100644
index 0000000..2f349e9
--- /dev/null
+++ b/src/Shared/DTOs/IssueDto.cs
@@ -0,0 +1,48 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     IssueDto.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.DTOs;
+
+/// <summary>
+///   IssueDto record
+/// </summary>
+[Serializable]
+public record IssueDto(
+	ObjectId Id,
+	string Title,
+	string Description,
+	DateTime DateCreated,
+	UserDto Author,
+	CategoryDto Category,
+	StatusDto Status)
+{
+	/// <summary>
+	///   Initializes a new instance of the <see cref="IssueDto" /> record from a Domain Issue.
+	/// </summary>
+	/// <param name="issue">The issue.</param>
+	public IssueDto(Domain.Issue issue) : this(
+		ObjectId.Parse(issue.Id),
+		issue.Title,
+		issue.Description ?? string.Empty,
+		issue.CreatedAt,
+		UserDto.Empty,
+		CategoryDto.Empty,
+		new StatusDto(issue.Status.ToString(), issue.Status.ToString(), null))
+	{
+	}
+
+	public static IssueDto Empty => new(
+		ObjectId.Empty,
+		string.Empty,
+		string.Empty,
+		DateTime.UtcNow,
+		UserDto.Empty,
+		CategoryDto.Empty,
+		StatusDto.Empty);
+}
diff --git a/src/Shared/DTOs/LabelDto.cs b/src/Shared/DTOs/LabelDto.cs
new file mode 100644
index 0000000..b49de80
--- /dev/null
+++ b/src/Shared/DTOs/LabelDto.cs
@@ -0,0 +1,9 @@
+namespace Shared.DTOs;
+
+public record LabelDto(string Name, string Color)
+{
+	/// <summary>
+	///   Gets an empty LabelDto instance.
+	/// </summary>
+	public static LabelDto Empty => new(string.Empty, string.Empty);
+}
\ No newline at end of file
diff --git a/src/Shared/DTOs/StatusDto.cs b/src/Shared/DTOs/StatusDto.cs
new file mode 100644
index 0000000..fd17ad8
--- /dev/null
+++ b/src/Shared/DTOs/StatusDto.cs
@@ -0,0 +1,27 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     StatusDto.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.DTOs;
+
+/// <summary>
+///   StatusDto record
+/// </summary>
+[Serializable]
+public record StatusDto(string StatusName, string StatusDescription, string? Id = null)
+{
+	/// <summary>
+	///   Initializes a new instance of the <see cref="Shared.DTOs.StatusDto" /> record.
+	/// </summary>
+	/// <param name="status">The status.</param>
+	public StatusDto(Status status) : this(status.StatusName, status.StatusDescription, status.Id.ToString())
+	{
+	}
+
+	public static StatusDto Empty => new(string.Empty, string.Empty, null);
+}
diff --git a/src/Shared/DTOs/UserDto.cs b/src/Shared/DTOs/UserDto.cs
new file mode 100644
index 0000000..efdc3e1
--- /dev/null
+++ b/src/Shared/DTOs/UserDto.cs
@@ -0,0 +1,27 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     UserDto.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.DTOs;
+
+/// <summary>
+///   UserDto record
+/// </summary>
+[Serializable]
+public record UserDto(string Id, string Name, string Email)
+{
+	/// <summary>
+	///   Initializes a new instance of the <see cref="Shared.DTOs.UserDto" /> record.
+	/// </summary>
+	/// <param name="user">The user.</param>
+	public UserDto(User user) : this(user.Id, user.Name, user.Email)
+	{
+	}
+
+	public static UserDto Empty => new(string.Empty, string.Empty, string.Empty);
+}
diff --git a/src/Shared/Domain/DTOs/CategoryDto.cs b/src/Shared/Domain/DTOs/CategoryDto.cs
deleted file mode 100644
index 54e9fb1..0000000
--- a/src/Shared/Domain/DTOs/CategoryDto.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace IssueManager.Shared.Domain.DTOs;
-
-/// <summary>
-///   Data transfer object for Category.
-/// </summary>
-/// <param name="Id">The unique identifier for the category.</param>
-/// <param name="CategoryName">The name of the category.</param>
-/// <param name="CategoryDescription">The description of the category.</param>
-/// <param name="Archived">Indicates whether the category is archived.</param>
-/// <param name="ArchivedBy">The user who archived the category.</param>
-public record CategoryDto(
-	string? Id,
-	string CategoryName,
-	string CategoryDescription,
-	bool Archived,
-	UserDto? ArchivedBy)
-{
-	/// <summary>
-	///   Gets an empty CategoryDto instance.
-	/// </summary>
-	public static CategoryDto Empty => new(
-		string.Empty,
-		string.Empty,
-		string.Empty,
-		false,
-		null);
-}
diff --git a/src/Shared/Domain/DTOs/CommentDto.cs b/src/Shared/Domain/DTOs/CommentDto.cs
deleted file mode 100644
index dd953d1..0000000
--- a/src/Shared/Domain/DTOs/CommentDto.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-namespace IssueManager.Shared.Domain.DTOs;
-
-/// <summary>
-///   Data transfer object for Comment.
-/// </summary>
-/// <param name="Id">The unique identifier for the comment.</param>
-/// <param name="Title">The title of the comment.</param>
-/// <param name="Description">The description of the comment.</param>
-/// <param name="DateCreated">The date the comment was created.</param>
-/// <param name="Issue">The issue this comment belongs to.</param>
-/// <param name="Author">The author of the comment.</param>
-/// <param name="UserVotes">The collection of user IDs who have voted.</param>
-/// <param name="Archived">Indicates whether the comment is archived.</param>
-/// <param name="ArchivedBy">The user who archived the comment.</param>
-/// <param name="IsAnswer">Indicates whether this comment is the selected answer.</param>
-/// <param name="AnswerSelectedBy">The user who selected this as the answer.</param>
-public record CommentDto(
-	string Id,
-	string Title,
-	string Description,
-	DateTime DateCreated,
-	IssueDto? Issue,
-	UserDto Author,
-	HashSet<string> UserVotes,
-	bool Archived,
-	UserDto? ArchivedBy,
-	bool IsAnswer,
-	UserDto? AnswerSelectedBy)
-{
-	/// <summary>
-	///   Gets an empty CommentDto instance.
-	/// </summary>
-	public static CommentDto Empty => new(
-		string.Empty,
-		string.Empty,
-		string.Empty,
-		DateTime.UtcNow,
-		null,
-		UserDto.Empty,
-		new HashSet<string>(),
-		false,
-		null,
-		false,
-		null);
-}
diff --git a/src/Shared/Domain/DTOs/IssueDto.cs b/src/Shared/Domain/DTOs/IssueDto.cs
deleted file mode 100644
index f136b60..0000000
--- a/src/Shared/Domain/DTOs/IssueDto.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-namespace IssueManager.Shared.Domain.DTOs;
-
-/// <summary>
-///   Data transfer object for Issue.
-/// </summary>
-/// <param name="Id">The unique identifier for the issue.</param>
-/// <param name="Title">The title of the issue.</param>
-/// <param name="Description">The description of the issue.</param>
-/// <param name="DateCreated">The date the issue was created.</param>
-/// <param name="Category">The category of the issue.</param>
-/// <param name="Author">The author of the issue.</param>
-/// <param name="IssueStatus">The status of the issue.</param>
-/// <param name="Archived">Indicates whether the issue is archived.</param>
-/// <param name="ArchivedBy">The user who archived the issue.</param>
-/// <param name="ApprovedForRelease">Indicates whether the issue is approved for release.</param>
-/// <param name="Rejected">Indicates whether the issue is rejected.</param>
-public record IssueDto(
-	string Id,
-	string Title,
-	string Description,
-	DateTime DateCreated,
-	CategoryDto Category,
-	UserDto Author,
-	StatusDto IssueStatus,
-	bool Archived,
-	UserDto? ArchivedBy,
-	bool ApprovedForRelease,
-	bool Rejected)
-{
-	/// <summary>
-	///   Gets an empty IssueDto instance.
-	/// </summary>
-	public static IssueDto Empty => new(
-		string.Empty,
-		string.Empty,
-		string.Empty,
-		DateTime.UtcNow,
-		CategoryDto.Empty,
-		UserDto.Empty,
-		StatusDto.Empty,
-		false,
-		null,
-		false,
-		false);
-}
diff --git a/src/Shared/Domain/DTOs/StatusDto.cs b/src/Shared/Domain/DTOs/StatusDto.cs
deleted file mode 100644
index 799bcf5..0000000
--- a/src/Shared/Domain/DTOs/StatusDto.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace IssueManager.Shared.Domain.DTOs;
-
-/// <summary>
-///   Data transfer object for Status.
-/// </summary>
-/// <param name="Id">The unique identifier for the status.</param>
-/// <param name="StatusName">The name of the status.</param>
-/// <param name="StatusDescription">The description of the status.</param>
-/// <param name="Archived">Indicates whether the status is archived.</param>
-/// <param name="ArchivedBy">The user who archived the status.</param>
-public record StatusDto(
-	string Id,
-	string StatusName,
-	string StatusDescription,
-	bool Archived,
-	UserDto? ArchivedBy)
-{
-	/// <summary>
-	///   Gets an empty StatusDto instance.
-	/// </summary>
-	public static StatusDto Empty => new(
-		string.Empty,
-		string.Empty,
-		string.Empty,
-		false,
-		null);
-}
diff --git a/src/Shared/Domain/DTOs/UserDto.cs b/src/Shared/Domain/DTOs/UserDto.cs
deleted file mode 100644
index a394017..0000000
--- a/src/Shared/Domain/DTOs/UserDto.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-namespace IssueManager.Shared.Domain.DTOs;
-
-/// <summary>
-///   Data transfer object for User (Auth0 user information).
-/// </summary>
-/// <param name="Id">The unique identifier for the user.</param>
-/// <param name="Name">The display name of the user.</param>
-/// <param name="Email">The email address of the user.</param>
-public record UserDto(
-	string Id,
-	string Name,
-	string Email)
-{
-	/// <summary>
-	///   Gets an empty UserDto instance.
-	/// </summary>
-	public static UserDto Empty => new(
-		string.Empty,
-		string.Empty,
-		string.Empty);
-}
diff --git a/src/Shared/Domain/Enums/IssueStatus.cs b/src/Shared/Domain/Enums/IssueStatus.cs
index 33f15b9..db412de 100644
--- a/src/Shared/Domain/Enums/IssueStatus.cs
+++ b/src/Shared/Domain/Enums/IssueStatus.cs
@@ -1,4 +1,4 @@
-namespace IssueManager.Shared.Domain.Enums;
+namespace Shared.Domain.Enums;
 
 /// <summary>
 ///   Represents the lifecycle status of an issue.
diff --git a/src/Shared/Domain/Issue.cs b/src/Shared/Domain/Issue.cs
index 04b0c06..465bbcd 100644
--- a/src/Shared/Domain/Issue.cs
+++ b/src/Shared/Domain/Issue.cs
@@ -1,4 +1,4 @@
-namespace IssueManager.Shared.Domain;
+namespace Shared.Domain;
 
 /// <summary>
 /// Represents an issue in the issue tracking system.
@@ -33,6 +33,26 @@ public record Issue(
 		? Title
 		: throw new ArgumentException("Issue title cannot be empty.", nameof(Title));
 
+	/// <summary>
+	/// Gets the detailed description of the issue.
+	/// </summary>
+	public string? Description { get; init; } = Description;
+
+	/// <summary>
+	/// Gets the current status of the issue.
+	/// </summary>
+	public IssueStatus Status { get; init; } = Status;
+
+	/// <summary>
+	/// Gets the timestamp when the issue was created.
+	/// </summary>
+	public DateTime CreatedAt { get; init; } = CreatedAt;
+
+	/// <summary>
+	/// Gets the timestamp when the issue was last updated.
+	/// </summary>
+	public DateTime UpdatedAt { get; init; } = UpdatedAt;
+
 	/// <summary>
 	/// Gets the collection of labels attached to the issue.
 	/// </summary>
@@ -80,4 +100,19 @@ public Issue Update(string title, string? description)
 			UpdatedAt = DateTime.UtcNow
 		};
 	}
+
+	/// <summary>
+	/// Gets a value indicating whether the issue is archived (soft-deleted).
+	/// </summary>
+	public bool IsArchived { get; init; } = false;
+
+	/// <summary>
+	/// Gets the user who archived the issue.
+	/// </summary>
+	public string? ArchivedBy { get; init; }
+
+	/// <summary>
+	/// Gets the timestamp when the issue was archived.
+	/// </summary>
+	public DateTime? ArchivedAt { get; init; }
 }
diff --git a/src/Shared/Domain/IssueStatus.cs b/src/Shared/Domain/IssueStatus.cs
index 026fc37..f5ce772 100644
--- a/src/Shared/Domain/IssueStatus.cs
+++ b/src/Shared/Domain/IssueStatus.cs
@@ -1,4 +1,4 @@
-namespace IssueManager.Shared.Domain;
+namespace Shared.Domain;
 
 /// <summary>
 /// Represents the possible states of an issue.
diff --git a/src/Shared/Domain/Label.cs b/src/Shared/Domain/Label.cs
index 95ae29e..d54105a 100644
--- a/src/Shared/Domain/Label.cs
+++ b/src/Shared/Domain/Label.cs
@@ -1,4 +1,4 @@
-namespace IssueManager.Shared.Domain;
+namespace Shared.Domain;
 
 /// <summary>
 /// Represents a label that can be attached to an issue for categorization.
diff --git a/src/Shared/Domain/Models/Category.cs b/src/Shared/Domain/Models/Category.cs
deleted file mode 100644
index 914b134..0000000
--- a/src/Shared/Domain/Models/Category.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-namespace IssueManager.Shared.Domain.Models;
-
-/// <summary>
-/// Represents a category for organizing and classifying issues.
-/// </summary>
-/// <param name="Id">The unique identifier for the category.</param>
-/// <param name="Name">The name of the category.</param>
-/// <param name="Description">The description of the category.</param>
-public record Category(string Id, string Name, string Description)
-{
-	/// <summary>
-	/// Gets the unique identifier for the category.
-	/// </summary>
-	public string Id { get; init; } = !string.IsNullOrWhiteSpace(Id)
-		? Id
-		: throw new ArgumentException("Category ID cannot be empty.", nameof(Id));
-
-	/// <summary>
-	/// Gets the name of the category.
-	/// </summary>
-	public string Name { get; init; } = !string.IsNullOrWhiteSpace(Name)
-		? Name
-		: throw new ArgumentException("Category name cannot be empty.", nameof(Name));
-
-	/// <summary>
-	/// Gets the description of the category.
-	/// </summary>
-	public string Description { get; init; } = !string.IsNullOrWhiteSpace(Description)
-		? Description
-		: throw new ArgumentException("Category description cannot be empty.", nameof(Description));
-}
diff --git a/src/Shared/Domain/Models/Comment.cs b/src/Shared/Domain/Models/Comment.cs
deleted file mode 100644
index a3886a6..0000000
--- a/src/Shared/Domain/Models/Comment.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-namespace IssueManager.Shared.Domain.Models;
-
-/// <summary>
-/// Represents a comment on an issue.
-/// </summary>
-/// <param name="Id">The unique identifier for the comment.</param>
-/// <param name="Title">The title of the comment.</param>
-/// <param name="Description">The description of the comment.</param>
-/// <param name="IssueId">The ID of the issue this comment belongs to.</param>
-/// <param name="AuthorId">The ID of the user who created the comment.</param>
-/// <param name="CreatedAt">The timestamp when the comment was created.</param>
-public record Comment(
-	string Id,
-	string Title,
-	string Description,
-	string IssueId,
-	string AuthorId,
-	DateTime CreatedAt)
-{
-	/// <summary>
-	/// Gets the unique identifier for the comment.
-	/// </summary>
-	public string Id { get; init; } = !string.IsNullOrWhiteSpace(Id)
-		? Id
-		: throw new ArgumentException("Comment ID cannot be empty.", nameof(Id));
-
-	/// <summary>
-	/// Gets the title of the comment.
-	/// </summary>
-	public string Title { get; init; } = !string.IsNullOrWhiteSpace(Title)
-		? Title
-		: throw new ArgumentException("Comment title cannot be empty.", nameof(Title));
-
-	/// <summary>
-	/// Gets the description of the comment.
-	/// </summary>
-	public string Description { get; init; } = !string.IsNullOrWhiteSpace(Description)
-		? Description
-		: throw new ArgumentException("Comment description cannot be empty.", nameof(Description));
-
-	/// <summary>
-	/// Gets the ID of the issue this comment belongs to.
-	/// </summary>
-	public string IssueId { get; init; } = !string.IsNullOrWhiteSpace(IssueId)
-		? IssueId
-		: throw new ArgumentException("Issue ID cannot be empty.", nameof(IssueId));
-
-	/// <summary>
-	/// Gets the ID of the user who created the comment.
-	/// </summary>
-	public string AuthorId { get; init; } = !string.IsNullOrWhiteSpace(AuthorId)
-		? AuthorId
-		: throw new ArgumentException("Author ID cannot be empty.", nameof(AuthorId));
-
-	/// <summary>
-	/// Gets the timestamp when the comment was created.
-	/// </summary>
-	public DateTime CreatedAt { get; init; } = CreatedAt != default ? CreatedAt : throw new ArgumentException("Created date cannot be default.", nameof(CreatedAt));
-
-	/// <summary>
-	/// Gets the user votes for this comment.
-	/// </summary>
-	public IReadOnlySet<string> UserVotes { get; init; } = new HashSet<string>();
-
-	/// <summary>
-	/// Gets a value indicating whether this comment is the selected answer.
-	/// </summary>
-	public bool IsAnswer { get; init; }
-
-	/// <summary>
-	/// Gets the ID of the user who selected this as the answer, if applicable.
-	/// </summary>
-	public string? AnswerSelectedById { get; init; }
-}
diff --git a/src/Shared/Domain/Models/GlobalUsings.cs b/src/Shared/Domain/Models/GlobalUsings.cs
deleted file mode 100644
index e69de29..0000000
diff --git a/src/Shared/Domain/Models/Issue.cs b/src/Shared/Domain/Models/Issue.cs
deleted file mode 100644
index d19d3b0..0000000
--- a/src/Shared/Domain/Models/Issue.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-namespace IssueManager.Shared.Domain.Models;
-
-/// <summary>
-/// Represents an issue in the issue tracking system.
-/// </summary>
-/// <param name="Id">The unique identifier for the issue.</param>
-/// <param name="Title">The title of the issue.</param>
-/// <param name="Description">The description of the issue.</param>
-/// <param name="AuthorId">The ID of the user who created the issue.</param>
-/// <param name="CreatedAt">The timestamp when the issue was created.</param>
-public record Issue(string Id, string Title, string Description, string AuthorId, DateTime CreatedAt)
-{
-	/// <summary>
-	/// Gets the unique identifier for the issue.
-	/// </summary>
-	public string Id { get; init; } = !string.IsNullOrWhiteSpace(Id)
-		? Id
-		: throw new ArgumentException("Issue ID cannot be empty.", nameof(Id));
-
-	/// <summary>
-	/// Gets the title of the issue.
-	/// </summary>
-	public string Title { get; init; } = !string.IsNullOrWhiteSpace(Title)
-		? Title
-		: throw new ArgumentException("Issue title cannot be empty.", nameof(Title));
-
-	/// <summary>
-	/// Gets the description of the issue.
-	/// </summary>
-	public string Description { get; init; } = !string.IsNullOrWhiteSpace(Description)
-		? Description
-		: throw new ArgumentException("Issue description cannot be empty.", nameof(Description));
-
-	/// <summary>
-	/// Gets the ID of the user who created the issue.
-	/// </summary>
-	public string AuthorId { get; init; } = !string.IsNullOrWhiteSpace(AuthorId)
-		? AuthorId
-		: throw new ArgumentException("Author ID cannot be empty.", nameof(AuthorId));
-
-	/// <summary>
-	/// Gets the timestamp when the issue was created.
-	/// </summary>
-	public DateTime CreatedAt { get; init; } = CreatedAt != default ? CreatedAt : throw new ArgumentException("Created date cannot be default.", nameof(CreatedAt));
-
-	/// <summary>
-	/// Gets the ID of the category.
-	/// </summary>
-	public string? CategoryId { get; init; }
-
-	/// <summary>
-	/// Gets the ID of the status.
-	/// </summary>
-	public string? StatusId { get; init; }
-
-	/// <summary>
-	/// Gets the timestamp when the issue was last updated.
-	/// </summary>
-	public DateTime? UpdatedAt { get; init; }
-
-	/// <summary>
-	/// Gets a value indicating whether this issue is archived.
-	/// </summary>
-	public bool IsArchived { get; init; }
-
-	/// <summary>
-	/// Gets a value indicating whether this issue is approved for release.
-	/// </summary>
-	public bool ApprovedForRelease { get; init; }
-
-	/// <summary>
-	/// Gets a value indicating whether this issue is rejected.
-	/// </summary>
-	public bool Rejected { get; init; }
-}
diff --git a/src/Shared/Domain/Models/Status.cs b/src/Shared/Domain/Models/Status.cs
deleted file mode 100644
index d9b64d2..0000000
--- a/src/Shared/Domain/Models/Status.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-namespace IssueManager.Shared.Domain.Models;
-
-/// <summary>
-/// Represents a status for tracking the lifecycle of an issue.
-/// </summary>
-/// <param name="Id">The unique identifier for the status.</param>
-/// <param name="Name">The name of the status.</param>
-/// <param name="Description">The description of the status.</param>
-public record Status(string Id, string Name, string Description)
-{
-	/// <summary>
-	/// Gets the unique identifier for the status.
-	/// </summary>
-	public string Id { get; init; } = !string.IsNullOrWhiteSpace(Id)
-		? Id
-		: throw new ArgumentException("Status ID cannot be empty.", nameof(Id));
-
-	/// <summary>
-	/// Gets the name of the status.
-	/// </summary>
-	public string Name { get; init; } = !string.IsNullOrWhiteSpace(Name)
-		? Name
-		: throw new ArgumentException("Status name cannot be empty.", nameof(Name));
-
-	/// <summary>
-	/// Gets the description of the status.
-	/// </summary>
-	public string Description { get; init; } = !string.IsNullOrWhiteSpace(Description)
-		? Description
-		: throw new ArgumentException("Status description cannot be empty.", nameof(Description));
-}
diff --git a/src/Shared/Domain/Models/User.cs b/src/Shared/Domain/Models/User.cs
deleted file mode 100644
index d01a100..0000000
--- a/src/Shared/Domain/Models/User.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-namespace IssueManager.Shared.Domain.Models;
-
-/// <summary>
-/// Represents a user in the system.
-/// </summary>
-/// <param name="Id">The unique identifier for the user.</param>
-/// <param name="Name">The display name of the user.</param>
-/// <param name="Email">The email address of the user.</param>
-public record User(string Id, string Name, string Email)
-{
-	/// <summary>
-	/// Gets the unique identifier for the user.
-	/// </summary>
-	public string Id { get; init; } = !string.IsNullOrWhiteSpace(Id)
-		? Id
-		: throw new ArgumentException("User ID cannot be empty.", nameof(Id));
-
-	/// <summary>
-	/// Gets the display name of the user.
-	/// </summary>
-	public string Name { get; init; } = !string.IsNullOrWhiteSpace(Name)
-		? Name
-		: throw new ArgumentException("User name cannot be empty.", nameof(Name));
-
-	/// <summary>
-	/// Gets the email address of the user.
-	/// </summary>
-	public string Email { get; init; } = !string.IsNullOrWhiteSpace(Email)
-		? Email
-		: throw new ArgumentException("User email cannot be empty.", nameof(Email));
-}
diff --git a/src/Shared/Exceptions/ConflictException.cs b/src/Shared/Exceptions/ConflictException.cs
new file mode 100644
index 0000000..6877ad0
--- /dev/null
+++ b/src/Shared/Exceptions/ConflictException.cs
@@ -0,0 +1,21 @@
+namespace Shared.Exceptions;
+
+/// <summary>
+/// Exception thrown when an operation conflicts with the current state of a resource.
+/// </summary>
+public class ConflictException : Exception
+{
+	/// <summary>
+	/// Initializes a new instance of the <see cref="ConflictException"/> class.
+	/// </summary>
+	public ConflictException(string message) : base(message)
+	{
+	}
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="ConflictException"/> class.
+	/// </summary>
+	public ConflictException(string message, Exception innerException) : base(message, innerException)
+	{
+	}
+}
diff --git a/src/Shared/Exceptions/NotFoundException.cs b/src/Shared/Exceptions/NotFoundException.cs
new file mode 100644
index 0000000..5801d61
--- /dev/null
+++ b/src/Shared/Exceptions/NotFoundException.cs
@@ -0,0 +1,21 @@
+namespace Shared.Exceptions;
+
+/// <summary>
+/// Exception thrown when a resource is not found.
+/// </summary>
+public class NotFoundException : Exception
+{
+	/// <summary>
+	/// Initializes a new instance of the <see cref="NotFoundException"/> class.
+	/// </summary>
+	public NotFoundException(string message) : base(message)
+	{
+	}
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="NotFoundException"/> class.
+	/// </summary>
+	public NotFoundException(string message, Exception innerException) : base(message, innerException)
+	{
+	}
+}
diff --git a/src/Shared/GlobalUsings.cs b/src/Shared/GlobalUsings.cs
new file mode 100644
index 0000000..22d8a6e
--- /dev/null
+++ b/src/Shared/GlobalUsings.cs
@@ -0,0 +1,14 @@
+// =======================================================
+// Copyright (c) 2026. All rights reserved.
+// File Name :     GlobalUsings.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =======================================================
+
+global using MongoDB.Bson;
+global using MongoDB.Bson.Serialization.Attributes;
+
+global using Shared.DTOs;
+global using Shared.Models;
diff --git a/src/Shared/Models/Category.cs b/src/Shared/Models/Category.cs
new file mode 100644
index 0000000..eb6c72b
--- /dev/null
+++ b/src/Shared/Models/Category.cs
@@ -0,0 +1,67 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     Category.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.Models;
+
+/// <summary>
+///   Category class
+/// </summary>
+[Serializable]
+public class Category
+{
+	/// <summary>
+	///   Gets or sets the identifier.
+	/// </summary>
+	/// <value>
+	///   The identifier.
+	/// </value>
+	[BsonId]
+	[BsonElement("_id")]
+	[BsonRepresentation(BsonType.ObjectId)]
+	public ObjectId Id { get; set; } = ObjectId.Empty;
+
+	/// <summary>
+	///   Gets or sets the name of the category.
+	/// </summary>
+	/// <value>
+	///   The name of the category.
+	/// </value>
+	[BsonElement("category_name")]
+	[BsonRepresentation(BsonType.String)]
+	public string CategoryName { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the category description.
+	/// </summary>
+	/// <value>
+	///   The category description.
+	/// </value>
+	[BsonElement("category-description")]
+	[BsonRepresentation(BsonType.String)]
+	public string CategoryDescription { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets a value indicating whether this <see cref="Category" /> is archived.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if archived; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("archived")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool Archived { get; set; }
+
+	/// <summary>
+	///   Gets or sets who archived the record.
+	/// </summary>
+	/// <value>
+	///   Who archived the record.
+	/// </value>
+	[BsonElement("archived_by")]
+	public UserDto ArchivedBy { get; set; } = UserDto.Empty;
+}
diff --git a/src/Shared/Models/Comment.cs b/src/Shared/Models/Comment.cs
new file mode 100644
index 0000000..8dad8bb
--- /dev/null
+++ b/src/Shared/Models/Comment.cs
@@ -0,0 +1,115 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     Comment.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.Models;
+
+[Serializable]
+public class Comment
+{
+	/// <summary>
+	///   Gets or sets the identifier.
+	/// </summary>
+	/// <value>
+	///   The identifier.
+	/// </value>
+	[BsonId]
+	[BsonRepresentation(BsonType.ObjectId)]
+	public ObjectId Id { get; set; } = ObjectId.Empty;
+
+	/// <summary>
+	///   Gets or sets the title.
+	/// </summary>
+	/// <value>
+	///   The title.
+	/// </value>
+	[BsonElement("comment_title")]
+	[BsonRepresentation(BsonType.String)]
+	public string Title { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the description.
+	/// </summary>
+	/// <value>
+	///   The description.
+	/// </value>
+	[BsonElement("comment_description")]
+	[BsonRepresentation(BsonType.String)]
+	public string Description { get; init; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the date created.
+	/// </summary>
+	/// <value>
+	///   The date created.
+	/// </value>
+	[BsonElement("date_created")]
+	[BsonRepresentation(BsonType.DateTime)]
+	public DateTime DateCreated { get; init; } = DateTime.UtcNow;
+
+	/// <summary>
+	///   Gets or sets the issue.
+	/// </summary>
+	/// <value>
+	///   The issue.
+	/// </value>
+	public IssueDto Issue { get; set; } = IssueDto.Empty;
+
+	/// <summary>
+	///   Gets or sets the author.
+	/// </summary>
+	/// <value>
+	///   The author.
+	/// </value>
+	public UserDto Author { get; set; } = UserDto.Empty;
+
+	/// <summary>
+	///   Gets or sets the user votes.
+	/// </summary>
+	/// <value>
+	///   The user votes.
+	/// </value>
+	public HashSet<string> UserVotes { get; init; } = new();
+
+	/// <summary>
+	///   Gets or sets a value indicating whether this <see cref="Comment" /> is archived.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if archived; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("archived")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool Archived { get; set; }
+
+	/// <summary>
+	///   Gets or sets who archived the record.
+	/// </summary>
+	/// <value>
+	///   Who archived the record.
+	/// </value>
+	[BsonElement("archived_by")]
+	public UserDto ArchivedBy { get; set; } = UserDto.Empty;
+
+	/// <summary>
+	///   Gets or sets that this comment is the selected answer to the associated Issue.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if is the answer; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("is_answer")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool IsAnswer { get; set; }
+
+	/// <summary>
+	///   Gets or sets the user that selected this comment as the answer to the associated Issue.
+	/// </summary>
+	/// <value>
+	///   Who selected this comment as the answer to the associated Issue.
+	/// </value>
+	public UserDto AnswerSelectedBy { get; set; } = UserDto.Empty;
+}
diff --git a/src/Shared/Models/Issue.cs b/src/Shared/Models/Issue.cs
new file mode 100644
index 0000000..d25bcea
--- /dev/null
+++ b/src/Shared/Models/Issue.cs
@@ -0,0 +1,120 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     Issue.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.Models;
+
+/// <summary>
+///   Issue class
+/// </summary>
+[Serializable]
+public class Issue
+{
+	/// <summary>
+	///   Gets or sets the identifier.
+	/// </summary>
+	/// <value>
+	///   The identifier.
+	/// </value>
+	[BsonId]
+	[BsonRepresentation(BsonType.ObjectId)]
+	public ObjectId Id { get; set; } = ObjectId.Empty;
+
+	/// <summary>
+	///   Gets or sets the title.
+	/// </summary>
+	/// <value>
+	///   The title.
+	/// </value>
+	[BsonElement("issue_title")]
+	[BsonRepresentation(BsonType.String)]
+	public string Title { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the description.
+	/// </summary>
+	/// <value>
+	///   The description.
+	/// </value>
+	[BsonElement("issue_description")]
+	[BsonRepresentation(BsonType.String)]
+	public string Description { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the date created.
+	/// </summary>
+	/// <value>
+	///   The date created.
+	/// </value>
+	[BsonElement("date_created")]
+	[BsonRepresentation(BsonType.DateTime)]
+	public DateTime DateCreated { get; init; } = DateTime.UtcNow;
+
+	/// <summary>
+	///   Gets or sets the category.
+	/// </summary>
+	/// <value>
+	///   The category.
+	/// </value>
+	public CategoryDto Category { get; set; } = CategoryDto.Empty;
+
+	/// <summary>
+	///   Gets or sets the author.
+	/// </summary>
+	/// <value>
+	///   The author.
+	/// </value>
+	public UserDto Author { get; set; } = UserDto.Empty;
+
+	/// <summary>
+	///   Gets or sets the issue status.
+	/// </summary>
+	/// <value>
+	///   The issue status.
+	/// </value>
+	public StatusDto IssueStatus { get; set; } = StatusDto.Empty;
+
+	/// <summary>
+	///   Gets or sets a value indicating whether this <see cref="Issue" /> is archived.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if archived; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("archived")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool Archived { get; set; }
+
+	/// <summary>
+	///   Gets or sets who archived the record.
+	/// </summary>
+	/// <value>
+	///   Who archived the record.
+	/// </value>
+	[BsonElement("archived_by")]
+	public UserDto ArchivedBy { get; set; } = UserDto.Empty;
+
+	/// <summary>
+	///   Gets or sets a value indicating whether [approved for release].
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if [approved for release]; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("approved_for_release")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool ApprovedForRelease { get; set; }
+
+	/// <summary>
+	///   Gets or sets a value indicating whether this <see cref="Issue" /> is rejected.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if rejected; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("rejected")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool Rejected { get; set; }
+}
diff --git a/src/Shared/Models/Status.cs b/src/Shared/Models/Status.cs
new file mode 100644
index 0000000..4c62e4f
--- /dev/null
+++ b/src/Shared/Models/Status.cs
@@ -0,0 +1,66 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     Status.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.Models;
+
+/// <summary>
+///   Status class
+/// </summary>
+[Serializable]
+public class Status
+{
+	/// <summary>
+	///   Gets or sets the identifier.
+	/// </summary>
+	/// <value>
+	///   The identifier.
+	/// </value>
+	[BsonId]
+	[BsonRepresentation(BsonType.ObjectId)]
+	public ObjectId Id { get; set; } = ObjectId.Empty;
+
+	/// <summary>
+	///   Gets or sets the name of the status.
+	/// </summary>
+	/// <value>
+	///   The name of the status.
+	/// </value>
+	[BsonElement("status_name")]
+	[BsonRepresentation(BsonType.String)]
+	public string StatusName { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the status description.
+	/// </summary>
+	/// <value>
+	///   The status description.
+	/// </value>
+	[BsonElement("status_description")]
+	[BsonRepresentation(BsonType.String)]
+	public string StatusDescription { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets a value indicating whether this <see cref="Status" /> is archived.
+	/// </summary>
+	/// <value>
+	///   <c>true</c> if archived; otherwise, <c>false</c>.
+	/// </value>
+	[BsonElement("archived")]
+	[BsonRepresentation(BsonType.Boolean)]
+	public bool Archived { get; set; }
+
+	/// <summary>
+	///   Gets or sets who archived the record.
+	/// </summary>
+	/// <value>
+	///   Who archived the record.
+	/// </value>
+	[BsonElement("archived_by")]
+	public UserDto ArchivedBy { get; set; } = UserDto.Empty;
+}
diff --git a/src/Shared/Models/User.cs b/src/Shared/Models/User.cs
new file mode 100644
index 0000000..d44ff94
--- /dev/null
+++ b/src/Shared/Models/User.cs
@@ -0,0 +1,42 @@
+// ============================================
+// Copyright (c) 2023. All rights reserved.
+// File Name :     User.cs
+// Company :       mpaulosky
+// Author :        Matthew Paulosky
+// Solution Name : IssueManager
+// Project Name :  Shared
+// =============================================
+
+namespace Shared.Models;
+
+/// <summary>
+///   User class
+/// </summary>
+[Serializable]
+public class User
+{
+	/// <summary>
+	///   Gets or sets the identifier.
+	/// </summary>
+	/// <value>
+	///   The identifier.
+	/// </value>
+	public string Id { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the name.
+	/// </summary>
+	/// <value>
+	///   The name.
+	/// </value>
+	public string Name { get; set; } = string.Empty;
+
+	/// <summary>
+	///   Gets or sets the email address.
+	/// </summary>
+	/// <value>
+	///   The email address.
+	/// </value>
+	public string Email { get; set; } = string.Empty;
+
+}
diff --git a/src/Shared/Shared.csproj b/src/Shared/Shared.csproj
index 9ae6006..11b181b 100644
--- a/src/Shared/Shared.csproj
+++ b/src/Shared/Shared.csproj
@@ -4,9 +4,10 @@
 		<LangVersion>14.0</LangVersion>
 		<Nullable>enable</Nullable>
 		<ImplicitUsings>enable</ImplicitUsings>
-		<RootNamespace>IssueManager.Shared</RootNamespace>
+		<RootNamespace>Shared</RootNamespace>
 	</PropertyGroup>
 	<ItemGroup>
 	  <PackageReference Include="FluentValidation" />
+	  <PackageReference Include="MongoDB.Bson" />
 	</ItemGroup>
 </Project>
diff --git a/src/Shared/Utilities.cs b/src/Shared/Utilities.cs
index f4f4ab7..baf13c9 100644
--- a/src/Shared/Utilities.cs
+++ b/src/Shared/Utilities.cs
@@ -1,4 +1,4 @@
-namespace IssueManager.Shared;
+namespace Shared;
 
 /// <summary>
 /// Placeholder utilities class for the Shared library.
diff --git a/src/Shared/Validators/CreateIssueValidator.cs b/src/Shared/Validators/CreateIssueValidator.cs
index 82862df..3dfa4f8 100644
--- a/src/Shared/Validators/CreateIssueValidator.cs
+++ b/src/Shared/Validators/CreateIssueValidator.cs
@@ -1,6 +1,6 @@
 using FluentValidation;
 
-namespace IssueManager.Shared.Validators;
+namespace Shared.Validators;
 
 /// <summary>
 /// Command for creating a new issue.
diff --git a/src/Shared/Validators/UpdateIssueStatusValidator.cs b/src/Shared/Validators/UpdateIssueStatusValidator.cs
index e117df8..dcf7406 100644
--- a/src/Shared/Validators/UpdateIssueStatusValidator.cs
+++ b/src/Shared/Validators/UpdateIssueStatusValidator.cs
@@ -1,7 +1,8 @@
 using FluentValidation;
-using IssueManager.Shared.Domain;
 
-namespace IssueManager.Shared.Validators;
+using Shared.Domain;
+
+namespace Shared.Validators;
 
 /// <summary>
 /// Command for updating the status of an issue.
diff --git a/src/Web/Components/CreateIssueRequest.cs b/src/Web/Components/CreateIssueRequest.cs
index 4dd37f2..bf5928a 100644
--- a/src/Web/Components/CreateIssueRequest.cs
+++ b/src/Web/Components/CreateIssueRequest.cs
@@ -1,5 +1,6 @@
 using System.ComponentModel.DataAnnotations;
-using IssueManager.Shared.Domain;
+
+using Shared.Domain;
 
 namespace IssueManager.Web.Components;
 
diff --git a/src/Web/Components/IssueForm.razor b/src/Web/Components/IssueForm.razor
index 251910f..74cb9bd 100644
--- a/src/Web/Components/IssueForm.razor
+++ b/src/Web/Components/IssueForm.razor
@@ -1,5 +1,5 @@
+@using global::Shared.Domain
 @namespace IssueManager.Web.Components
-@using IssueManager.Shared.Domain
 
 <div class="form-container">
 	<EditForm Model="@FormModel" OnValidSubmit="@OnFormSubmit">
diff --git a/src/Web/_Imports.razor b/src/Web/_Imports.razor
index a980293..74b8772 100644
--- a/src/Web/_Imports.razor
+++ b/src/Web/_Imports.razor
@@ -7,3 +7,4 @@
 @using IssueManager.Web.Layout
 @using IssueManager.Web.Pages
 @using IssueManager.Web.Components
+@using global::Shared.Domain
diff --git a/tests/Architecture/ArchitectureTests.cs b/tests/Architecture/ArchitectureTests.cs
index 26185ab..8a371fb 100644
--- a/tests/Architecture/ArchitectureTests.cs
+++ b/tests/Architecture/ArchitectureTests.cs
@@ -1,5 +1,9 @@
 using FluentAssertions;
 using NetArchTest.Rules;
+
+using Shared.Domain;
+using Shared.Validators;
+
 using Xunit;
 
 namespace IssueManager.Tests.Architecture;
@@ -25,7 +29,7 @@ public class ArchitectureTests
 	public void SharedLayer_ShouldNotDependOnHigherLayers()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Domain.Label).Assembly;
+		var sharedAssembly = typeof(Label).Assembly;
 
 		// Act
 		var result = Types.InAssembly(sharedAssembly)
@@ -48,7 +52,7 @@ public void SharedLayer_ShouldNotDependOnHigherLayers()
 	public void DomainModels_ShouldNotDependOnInfrastructure()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Domain.Issue).Assembly;
+		var sharedAssembly = typeof(Issue).Assembly;
 
 		// Act
 		var result = Types.InAssembly(sharedAssembly)
@@ -71,7 +75,7 @@ public void DomainModels_ShouldNotDependOnInfrastructure()
 	public void Validators_ShouldOnlyDependOnFluentValidationAndDomain()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Validators.CreateIssueValidator).Assembly;
+		var sharedAssembly = typeof(CreateIssueValidator).Assembly;
 
 		// Act
 		var result = Types.InAssembly(sharedAssembly)
@@ -95,7 +99,7 @@ public void Validators_ShouldOnlyDependOnFluentValidationAndDomain()
 	public void Validators_ShouldNotDependOnHigherLayers()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Validators.CreateIssueValidator).Assembly;
+		var sharedAssembly = typeof(CreateIssueValidator).Assembly;
 
 		// Act
 		var result = Types.InAssembly(sharedAssembly)
@@ -111,13 +115,13 @@ public void Validators_ShouldNotDependOnHigherLayers()
 	}
 
 	/// <summary>
-	/// Ensures that all validator classes follow the naming convention of ending with "Validator".
+	/// Ensures that all validator classes follow the naming convention of ending with "Validator", "Command", or "Query".
 	/// </summary>
 	[Fact]
 	public void Validators_ShouldFollowNamingConvention()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Validators.CreateIssueValidator).Assembly;
+		var sharedAssembly = typeof(CreateIssueValidator).Assembly;
 
 		// Act
 		var result = Types.InAssembly(sharedAssembly)
@@ -129,11 +133,13 @@ public void Validators_ShouldFollowNamingConvention()
 			.HaveNameEndingWith("Validator")
 			.Or()
 			.HaveNameEndingWith("Command")
+			.Or()
+			.HaveNameEndingWith("Query")
 			.GetResult();
 
 		// Assert
 		result.IsSuccessful.Should().BeTrue(
-			"All validator classes should end with 'Validator' or be command DTOs ending with 'Command'");
+			"All validator classes should end with 'Validator', 'Command', or 'Query'");
 	}
 
 	/// <summary>
@@ -143,7 +149,7 @@ public void Validators_ShouldFollowNamingConvention()
 	public void DomainModels_ShouldBeRecords()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Domain.Issue).Assembly;
+		var sharedAssembly = typeof(Issue).Assembly;
 
 		// Act
 		var domainTypes = Types.InAssembly(sharedAssembly)
@@ -254,7 +260,7 @@ public void ServiceDefaults_ShouldHaveMinimalDependencies()
 	public void SharedLayer_PublicTypesShouldHaveDocumentation()
 	{
 		// Arrange
-		var sharedAssembly = typeof(IssueManager.Shared.Domain.Issue).Assembly;
+		var sharedAssembly = typeof(Issue).Assembly;
 
 		// Act - Note: This test checks that types are defined; XML doc enforcement is done by compiler warnings
 		var publicTypes = Types.InAssembly(sharedAssembly)
diff --git a/tests/BlazorTests/Components/IssueFormTests.cs b/tests/BlazorTests/Components/IssueFormTests.cs
index 4bf71c0..9db57c9 100644
--- a/tests/BlazorTests/Components/IssueFormTests.cs
+++ b/tests/BlazorTests/Components/IssueFormTests.cs
@@ -1,9 +1,12 @@
 using Bunit;
 using FluentAssertions;
-using IssueManager.Shared.Domain;
+
 using IssueManager.Tests.BlazorTests.Fixtures;
 using IssueManager.Web.Components;
 using Microsoft.AspNetCore.Components;
+
+using Shared.Domain;
+
 using Xunit;
 
 namespace IssueManager.Tests.BlazorTests.Components;
diff --git a/tests/BlazorTests/GlobalUsings.cs b/tests/BlazorTests/GlobalUsings.cs
index f766095..7786790 100644
--- a/tests/BlazorTests/GlobalUsings.cs
+++ b/tests/BlazorTests/GlobalUsings.cs
@@ -2,5 +2,5 @@
 global using FluentAssertions;
 global using Bunit;
 global using NSubstitute;
-global using IssueManager.Shared.Domain;
+
 global using IssueManager.Web.Components;
diff --git a/tests/Integration/Data/IssueRepositoryTests.cs b/tests/Integration/Data/IssueRepositoryTests.cs
index a3ba581..af45ff5 100644
--- a/tests/Integration/Data/IssueRepositoryTests.cs
+++ b/tests/Integration/Data/IssueRepositoryTests.cs
@@ -1,6 +1,6 @@
 using FluentAssertions;
 using IssueManager.Api.Data;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
 using Testcontainers.MongoDb;
 
 namespace IssueManager.Tests.Integration.Data;
@@ -10,336 +10,333 @@ namespace IssueManager.Tests.Integration.Data;
 /// </summary>
 public class IssueRepositoryTests : IAsyncLifetime
 {
-	private const string MONGODB_IMAGE = "mongo:8.0";
-	private const string TEST_DATABASE = "IssueManagerTestDb";
-	private readonly MongoDbContainer _mongoContainer;
-
-	private IIssueRepository _repository = null!;
-
-	public IssueRepositoryTests()
-	{
-		_mongoContainer = new MongoDbBuilder()
-			.WithImage(MONGODB_IMAGE)
-			.Build();
-	}
-
-	/// <summary>
-	/// Initializes the test container and repository.
-	/// </summary>
-	public async Task InitializeAsync()
-	{
-		await _mongoContainer.StartAsync();
-		var connectionString = _mongoContainer.GetConnectionString();
-		_repository = new IssueRepository(connectionString, TEST_DATABASE);
-	}
-
-	/// <summary>
-	/// Disposes the test container.
-	/// </summary>
-	public async Task DisposeAsync()
-	{
-		await _mongoContainer.StopAsync();
-		await _mongoContainer.DisposeAsync();
-	}
-
-	[Fact]
-	public async Task GetAllAsync_FirstPage_ReturnsCorrectItems()
-	{
-		// Arrange - Create 50 issues
-		for (int i = 0; i < 50; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		// Act
-		var result = await _repository.GetAllAsync(page: 1, pageSize: 20, includeArchived: false);
-
-		// Assert
-		result.Should().HaveCount(20);
-	}
-
-	[Fact]
-	public async Task GetAllAsync_SecondPage_ReturnsNextSetOfItems()
-	{
-		// Arrange - Create 50 issues
-		var issueIds = new List<string>();
-		for (int i = 0; i < 50; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-			issueIds.Add(issue.Id);
-		}
-
-		// Act
-		var page1 = await _repository.GetAllAsync(page: 1, pageSize: 20, includeArchived: false);
-		var page2 = await _repository.GetAllAsync(page: 2, pageSize: 20, includeArchived: false);
-
-		// Assert
-		page2.Should().HaveCount(20);
-		page1.Select(i => i.Id).Should().NotIntersectWith(page2.Select(i => i.Id)); // No overlap
-	}
-
-	[Fact]
-	public async Task GetAllAsync_ExcludesArchived_ByDefault()
-	{
-		// Arrange - Create 10 issues, archive 3
-		for (int i = 0; i < 10; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i))
-			{
-				IsArchived = i < 3 // Archive first 3
-			};
-
-			await _repository.CreateAsync(issue);
-		}
-
-		// Act
-		var result = await _repository.GetAllAsync(page: 1, pageSize: 20, includeArchived: false);
-
-		// Assert
-		result.Should().HaveCount(7); // 10 - 3 archived = 7
-		result.Should().OnlyContain(i => !i.IsArchived);
-	}
-
-	[Fact]
-	public async Task GetAllAsync_IncludesArchived_WhenRequested()
-	{
-		// Arrange - Create 10 issues, archive 3
-		for (int i = 0; i < 10; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i))
-			{
-				IsArchived = i < 3
-			};
-
-			await _repository.CreateAsync(issue);
-		}
-
-		// Act
-		var result = await _repository.GetAllAsync(page: 1, pageSize: 20, includeArchived: true);
-
-		// Assert
-		result.Should().HaveCount(10); // All issues including archived
-	}
-
-	[Fact]
-	public async Task CountAsync_ExcludesArchived_ByDefault()
-	{
-		// Arrange - Create 10 issues, archive 3
-		for (int i = 0; i < 10; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i))
-			{
-				IsArchived = i < 3
-			};
-
-			await _repository.CreateAsync(issue);
-		}
-
-		// Act
-		var count = await _repository.CountAsync(includeArchived: false);
-
-		// Assert
-		count.Should().Be(7); // 10 - 3 archived = 7
-	}
-
-	[Fact]
-	public async Task CountAsync_IncludesArchived_WhenRequested()
-	{
-		// Arrange - Create 10 issues, archive 3
-		for (int i = 0; i < 10; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i))
-			{
-				IsArchived = i < 3
-			};
-
-			await _repository.CreateAsync(issue);
-		}
-
-		// Act
-		var count = await _repository.CountAsync(includeArchived: true);
-
-		// Assert
-		count.Should().Be(10); // All issues
-	}
-
-	[Fact]
-	public async Task ArchiveAsync_SetsIsArchivedToTrue()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Archive",
-			Description: "Test",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow)
-		{
-			IsArchived = false
-		};
-
-		await _repository.CreateAsync(issue);
-
-		// Act
-		var archivedIssue = issue with { IsArchived = true, UpdatedAt = DateTime.UtcNow };
-		var result = await _repository.UpdateAsync(archivedIssue);
-
-		// Assert
-		result.Should().NotBeNull();
-		result!.IsArchived.Should().BeTrue();
-
-		// Verify in database
-		var dbIssue = await _repository.GetByIdAsync(issue.Id);
-		dbIssue!.IsArchived.Should().BeTrue();
-	}
-
-	[Fact]
-	public async Task ArchiveAsync_UpdatesTimestamp()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Archive",
-			Description: "Test",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
-		{
-			IsArchived = false,
-			UpdatedAt = DateTime.UtcNow.AddHours(-2)
-		};
-
-		await _repository.CreateAsync(issue);
-
-		// Act
-		var archivedIssue = issue with { IsArchived = true, UpdatedAt = DateTime.UtcNow };
-		var result = await _repository.UpdateAsync(archivedIssue);
-
-		// Assert
-		result!.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-		result.UpdatedAt.Should().BeAfter(issue.UpdatedAt!.Value);
-	}
-
-	[Fact]
-	public async Task ArchiveAsync_DoesNotDeleteRecord()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Archive",
-			Description: "Should still exist",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(issue);
-
-		// Act - Soft delete (archive)
-		var archivedIssue = issue with { IsArchived = true, UpdatedAt = DateTime.UtcNow };
-		await _repository.UpdateAsync(archivedIssue);
-
-		// Assert - Record still exists
-		var dbIssue = await _repository.GetByIdAsync(issue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.Id.Should().Be(issue.Id);
-		dbIssue.IsArchived.Should().BeTrue();
-	}
-
-	[Fact]
-	public async Task UpdateAsync_NonExistentIssue_ReturnsNull()
-	{
-		// Arrange
-		var nonExistentIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Non-existent",
-			Description: "Does not exist",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		// Act
-		var result = await _repository.UpdateAsync(nonExistentIssue);
-
-		// Assert
-		result.Should().BeNull();
-	}
-
-	[Fact]
-	public async Task GetAllAsync_OrdersByCreatedAtDescending()
-	{
-		// Arrange - Create issues with specific timestamps
-		var issue1 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Oldest",
-			Description: "Created first",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-3));
-
-		var issue2 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Middle",
-			Description: "Created second",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-2));
-
-		var issue3 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Newest",
-			Description: "Created last",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1));
-
-		await _repository.CreateAsync(issue1);
-		await _repository.CreateAsync(issue2);
-		await _repository.CreateAsync(issue3);
-
-		// Act
-		var result = await _repository.GetAllAsync(page: 1, pageSize: 10, includeArchived: false);
-
-		// Assert
-		result.Should().HaveCount(3);
-		result[0].Title.Should().Be("Newest"); // Newest first
-		result[1].Title.Should().Be("Middle");
-		result[2].Title.Should().Be("Oldest"); // Oldest last
-	}
-
-	[Fact]
-	public async Task GetAllAsync_EmptyDatabase_ReturnsEmptyList()
-	{
-		// Act
-		var result = await _repository.GetAllAsync(page: 1, pageSize: 20, includeArchived: false);
-
-		// Assert
-		result.Should().BeEmpty();
-	}
+private const string MONGODB_IMAGE = "mongo:8.0";
+private const string TEST_DATABASE = "IssueManagerTestDb";
+private readonly MongoDbContainer _mongoContainer;
+
+private IIssueRepository _repository = null!;
+
+public IssueRepositoryTests()
+{
+_mongoContainer = new MongoDbBuilder()
+.WithImage(MONGODB_IMAGE)
+.Build();
+}
+
+/// <summary>
+/// Initializes the test container and repository.
+/// </summary>
+public async Task InitializeAsync()
+{
+await _mongoContainer.StartAsync();
+var connectionString = _mongoContainer.GetConnectionString();
+_repository = new IssueRepository(connectionString, TEST_DATABASE);
+}
+
+/// <summary>
+/// Disposes the test container.
+/// </summary>
+public async Task DisposeAsync()
+{
+await _mongoContainer.StopAsync();
+await _mongoContainer.DisposeAsync();
+}
+
+[Fact]
+public async Task GetAllAsync_FirstPage_ReturnsCorrectItems()
+{
+// Arrange - Create 50 issues
+for (int i = 0; i < 50; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+// Act
+var (items, total) = await _repository.GetAllAsync(page: 1, pageSize: 20);
+
+// Assert
+items.Should().HaveCount(20);
+total.Should().Be(50);
+}
+
+[Fact]
+public async Task GetAllAsync_SecondPage_ReturnsNextSetOfItems()
+{
+// Arrange - Create 50 issues
+for (int i = 0; i < 50; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+// Act
+var (page1Items, _) = await _repository.GetAllAsync(page: 1, pageSize: 20);
+var (page2Items, _) = await _repository.GetAllAsync(page: 2, pageSize: 20);
+
+// Assert
+page2Items.Should().HaveCount(20);
+page1Items.Select(i => i.Id).Should().NotIntersectWith(page2Items.Select(i => i.Id)); // No overlap
+}
+
+[Fact]
+public async Task GetAllAsync_ExcludesArchived_ByDefault()
+{
+// Arrange - Create 10 issues, archive 3
+var issuesToArchive = new List<string>();
+for (int i = 0; i < 10; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+if (i < 3)
+issuesToArchive.Add(issue.Id);
+}
+
+foreach (var id in issuesToArchive)
+{
+await _repository.ArchiveAsync(id);
+}
+
+// Act
+var (items, total) = await _repository.GetAllAsync(page: 1, pageSize: 20);
+
+// Assert
+items.Should().HaveCount(7); // 10 - 3 archived = 7
+total.Should().Be(7);
+items.Should().OnlyContain(i => !i.IsArchived);
+}
+
+[Fact]
+public async Task GetAllAsync_All_IncludesArchivedIssues()
+{
+// Arrange - Create 10 issues, archive 3
+var issuesToArchive = new List<string>();
+for (int i = 0; i < 10; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+if (i < 3)
+issuesToArchive.Add(issue.Id);
+}
+
+foreach (var id in issuesToArchive)
+{
+await _repository.ArchiveAsync(id);
+}
+
+// Act — non-paginated GetAllAsync returns all records
+var allIssues = await _repository.GetAllAsync();
+
+// Assert
+allIssues.Should().HaveCount(10); // All issues including archived
+}
+
+[Fact]
+public async Task CountAsync_ReturnsTotalIssueCount()
+{
+// Arrange - Create 10 issues, archive 3
+var issuesToArchive = new List<string>();
+for (int i = 0; i < 10; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+if (i < 3)
+issuesToArchive.Add(issue.Id);
+}
+
+foreach (var id in issuesToArchive)
+{
+await _repository.ArchiveAsync(id);
+}
+
+// Act
+var count = await _repository.CountAsync();
+
+// Assert — CountAsync counts all issues regardless of archive status
+count.Should().Be(10);
+}
+
+[Fact]
+public async Task ArchiveAsync_SetsIsArchivedToTrue()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Archive",
+Description: "Test",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow)
+{
+IsArchived = false
+};
+
+await _repository.CreateAsync(issue);
+
+// Act
+var result = await _repository.ArchiveAsync(issue.Id);
+
+// Assert
+result.Should().BeTrue();
+
+// Verify in database
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.IsArchived.Should().BeTrue();
+}
+
+[Fact]
+public async Task ArchiveAsync_UpdatesTimestamp()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Archive",
+Description: "Test",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-1),
+UpdatedAt: DateTime.UtcNow.AddHours(-2));
+
+await _repository.CreateAsync(issue);
+
+// Act
+await _repository.ArchiveAsync(issue.Id);
+
+// Assert
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
+dbIssue.UpdatedAt.Should().BeAfter(issue.UpdatedAt);
+}
+
+[Fact]
+public async Task ArchiveAsync_DoesNotDeleteRecord()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Archive",
+Description: "Should still exist",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(issue);
+
+// Act - Soft delete (archive)
+await _repository.ArchiveAsync(issue.Id);
+
+// Assert - Record still exists
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.Id.Should().Be(issue.Id);
+dbIssue.IsArchived.Should().BeTrue();
+}
+
+[Fact]
+public async Task UpdateAsync_NonExistentIssue_ReturnsNull()
+{
+// Arrange
+var nonExistentIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Non-existent",
+Description: "Does not exist",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+// Act
+var result = await _repository.UpdateAsync(nonExistentIssue);
+
+// Assert
+result.Should().BeNull();
+}
+
+[Fact]
+public async Task GetAllAsync_OrdersByCreatedAtDescending()
+{
+// Arrange - Create issues with specific timestamps
+var issue1 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Oldest",
+Description: "Created first",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-3),
+UpdatedAt: DateTime.UtcNow.AddDays(-3));
+
+var issue2 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Middle",
+Description: "Created second",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-2),
+UpdatedAt: DateTime.UtcNow.AddDays(-2));
+
+var issue3 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Newest",
+Description: "Created last",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-1),
+UpdatedAt: DateTime.UtcNow.AddDays(-1));
+
+await _repository.CreateAsync(issue1);
+await _repository.CreateAsync(issue2);
+await _repository.CreateAsync(issue3);
+
+// Act
+var (items, _) = await _repository.GetAllAsync(page: 1, pageSize: 10);
+
+// Assert
+items.Should().HaveCount(3);
+items[0].Title.Should().Be("Newest"); // Newest first
+items[1].Title.Should().Be("Middle");
+items[2].Title.Should().Be("Oldest"); // Oldest last
+}
+
+[Fact]
+public async Task GetAllAsync_EmptyDatabase_ReturnsEmptyList()
+{
+// Act
+var (items, total) = await _repository.GetAllAsync(page: 1, pageSize: 20);
+
+// Assert
+items.Should().BeEmpty();
+total.Should().Be(0);
+}
 }
diff --git a/tests/Integration/GlobalUsings.cs b/tests/Integration/GlobalUsings.cs
index 3599380..cb4f128 100644
--- a/tests/Integration/GlobalUsings.cs
+++ b/tests/Integration/GlobalUsings.cs
@@ -4,7 +4,6 @@
 global using Testcontainers.MongoDb;
 global using DotNet.Testcontainers.Builders;
 global using MongoDB.Driver;
-global using IssueManager.Shared.Domain;
-global using IssueManager.Shared.Validators;
+
 global using IssueManager.Api.Data;
 global using IssueManager.Api.Handlers;
diff --git a/tests/Integration/Handlers/CreateIssueHandlerTests.cs b/tests/Integration/Handlers/CreateIssueHandlerTests.cs
index 41a9749..c35f876 100644
--- a/tests/Integration/Handlers/CreateIssueHandlerTests.cs
+++ b/tests/Integration/Handlers/CreateIssueHandlerTests.cs
@@ -1,5 +1,8 @@
 using IssueManager.Tests.Integration.Fixtures;
 
+using Shared.Domain;
+using Shared.Validators;
+
 namespace IssueManager.Tests.Integration.Handlers;
 
 /// <summary>
diff --git a/tests/Integration/Handlers/DeleteIssueHandlerIntegrationTests.cs b/tests/Integration/Handlers/DeleteIssueHandlerIntegrationTests.cs
index 40b5779..234a80c 100644
--- a/tests/Integration/Handlers/DeleteIssueHandlerIntegrationTests.cs
+++ b/tests/Integration/Handlers/DeleteIssueHandlerIntegrationTests.cs
@@ -1,7 +1,9 @@
 using FluentAssertions;
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
+using global::Shared.Exceptions;
+using IssueManager.Shared.Validators;
 using Testcontainers.MongoDb;
 
 namespace IssueManager.Tests.Integration.Handlers;
@@ -11,190 +13,194 @@ namespace IssueManager.Tests.Integration.Handlers;
 /// </summary>
 public class DeleteIssueHandlerIntegrationTests : IAsyncLifetime
 {
-	private const string MONGODB_IMAGE = "mongo:8.0";
-	private const string TEST_DATABASE = "IssueManagerTestDb";
-	private readonly MongoDbContainer _mongoContainer;
-
-	private IIssueRepository _repository = null!;
-	private DeleteIssueHandler _handler = null!;
-
-	public DeleteIssueHandlerIntegrationTests()
-	{
-		_mongoContainer = new MongoDbBuilder()
-			.WithImage(MONGODB_IMAGE)
-			.Build();
-	}
-
-	/// <summary>
-	/// Initializes the test container and repository.
-	/// </summary>
-	public async Task InitializeAsync()
-	{
-		await _mongoContainer.StartAsync();
-		var connectionString = _mongoContainer.GetConnectionString();
-		_repository = new IssueRepository(connectionString, TEST_DATABASE);
-		_handler = new DeleteIssueHandler(_repository);
-	}
-
-	/// <summary>
-	/// Disposes the test container.
-	/// </summary>
-	public async Task DisposeAsync()
-	{
-		await _mongoContainer.StopAsync();
-		await _mongoContainer.DisposeAsync();
-	}
-
-	[Fact]
-	public async Task Handle_ValidIssue_SetsIsArchivedInDatabase()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Delete",
-			Description: "This will be archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow)
-		{
-			IsArchived = false
-		};
-
-		await _repository.CreateAsync(issue);
-
-		var command = new DeleteIssueCommand { Id = issue.Id };
-
-		// Act
-		await _handler.Handle(command, CancellationToken.None);
-
-		// Assert - Verify IsArchived is set in database
-		var dbIssue = await _repository.GetByIdAsync(issue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.IsArchived.Should().BeTrue();
-		dbIssue.UpdatedAt.Should().NotBeNull();
-		dbIssue.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-	}
-
-	[Fact]
-	public async Task Handle_ArchivedIssue_ExcludedFromListByDefault()
-	{
-		// Arrange - Create and archive an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Archive",
-			Description: "Test",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(issue);
-
-		var command = new DeleteIssueCommand { Id = issue.Id };
-
-		// Act - Archive the issue
-		await _handler.Handle(command, CancellationToken.None);
-
-		// Assert - GetAll should exclude archived issues
-		var allIssues = await _repository.GetAllAsync(1, 100, includeArchived: false);
-		allIssues.Should().NotContain(i => i.Id == issue.Id);
-	}
-
-	[Fact]
-	public async Task Handle_NonExistentIssue_ThrowsNotFoundException()
-	{
-		// Arrange
-		var nonExistentId = Guid.NewGuid().ToString();
-		var command = new DeleteIssueCommand { Id = nonExistentId };
-
-		// Act
-		Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		await act.Should().ThrowAsync<NotFoundException>();
-	}
-
-	[Fact]
-	public async Task Handle_IssueNotDeleted_RecordStillExists()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue to Archive",
-			Description: "Should still exist in DB",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(issue);
-
-		var command = new DeleteIssueCommand { Id = issue.Id };
-
-		// Act - Soft delete
-		await _handler.Handle(command, CancellationToken.None);
-
-		// Assert - Record should still exist (soft delete)
-		var dbIssue = await _repository.GetByIdAsync(issue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.Id.Should().Be(issue.Id);
-		dbIssue.IsArchived.Should().BeTrue();
-	}
-
-	[Fact]
-	public async Task Handle_AlreadyArchivedIssue_IsIdempotent()
-	{
-		// Arrange - Create an already archived issue
-		var archivedIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Already Archived",
-			Description: "Already archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow)
-		{
-			IsArchived = true,
-			UpdatedAt = DateTime.UtcNow.AddHours(-1)
-		};
-
-		await _repository.CreateAsync(archivedIssue);
-
-		var command = new DeleteIssueCommand { Id = archivedIssue.Id };
-
-		// Act - Delete already archived issue (should be idempotent)
-		await _handler.Handle(command, CancellationToken.None);
-
-		// Assert - Should still be archived
-		var dbIssue = await _repository.GetByIdAsync(archivedIssue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.IsArchived.Should().BeTrue();
-	}
-
-	[Fact]
-	public async Task Handle_MultipleIssues_ArchivesOnlySpecifiedIssue()
-	{
-		// Arrange - Create multiple issues
-		var issue1 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue 1",
-			Description: "To be archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		var issue2 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Issue 2",
-			Description: "Should remain active",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(issue1);
-		await _repository.CreateAsync(issue2);
-
-		var command = new DeleteIssueCommand { Id = issue1.Id };
-
-		// Act
-		await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		var dbIssue1 = await _repository.GetByIdAsync(issue1.Id);
-		var dbIssue2 = await _repository.GetByIdAsync(issue2.Id);
-
-		dbIssue1!.IsArchived.Should().BeTrue();
-		dbIssue2!.IsArchived.Should().BeFalse();
-	}
+private const string MONGODB_IMAGE = "mongo:8.0";
+private const string TEST_DATABASE = "IssueManagerTestDb";
+private readonly MongoDbContainer _mongoContainer;
+
+private IIssueRepository _repository = null!;
+private DeleteIssueHandler _handler = null!;
+
+public DeleteIssueHandlerIntegrationTests()
+{
+_mongoContainer = new MongoDbBuilder()
+.WithImage(MONGODB_IMAGE)
+.Build();
+}
+
+/// <summary>
+/// Initializes the test container and repository.
+/// </summary>
+public async Task InitializeAsync()
+{
+await _mongoContainer.StartAsync();
+var connectionString = _mongoContainer.GetConnectionString();
+_repository = new IssueRepository(connectionString, TEST_DATABASE);
+_handler = new DeleteIssueHandler(_repository, new DeleteIssueValidator());
+}
+
+/// <summary>
+/// Disposes the test container.
+/// </summary>
+public async Task DisposeAsync()
+{
+await _mongoContainer.StopAsync();
+await _mongoContainer.DisposeAsync();
+}
+
+[Fact]
+public async Task Handle_ValidIssue_SetsIsArchivedInDatabase()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Delete",
+Description: "This will be archived",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow)
+{
+IsArchived = false
+};
+
+await _repository.CreateAsync(issue);
+
+var command = new DeleteIssueCommand { Id = issue.Id };
+
+// Act
+await _handler.Handle(command, CancellationToken.None);
+
+// Assert - Verify IsArchived is set in database
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.IsArchived.Should().BeTrue();
+dbIssue.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
+}
+
+[Fact]
+public async Task Handle_ArchivedIssue_ExcludedFromListByDefault()
+{
+// Arrange - Create and archive an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Archive",
+Description: "Test",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(issue);
+
+var command = new DeleteIssueCommand { Id = issue.Id };
+
+// Act - Archive the issue
+await _handler.Handle(command, CancellationToken.None);
+
+// Assert - GetAll (paginated) should exclude archived issues
+var (allIssues, _) = await _repository.GetAllAsync(1, 100);
+allIssues.Should().NotContain(i => i.Id == issue.Id);
+}
+
+[Fact]
+public async Task Handle_NonExistentIssue_ThrowsNotFoundException()
+{
+// Arrange
+var nonExistentId = Guid.NewGuid().ToString();
+var command = new DeleteIssueCommand { Id = nonExistentId };
+
+// Act
+Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+await act.Should().ThrowAsync<NotFoundException>();
+}
+
+[Fact]
+public async Task Handle_IssueNotDeleted_RecordStillExists()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue to Archive",
+Description: "Should still exist in DB",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(issue);
+
+var command = new DeleteIssueCommand { Id = issue.Id };
+
+// Act - Soft delete
+await _handler.Handle(command, CancellationToken.None);
+
+// Assert - Record should still exist (soft delete)
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.Id.Should().Be(issue.Id);
+dbIssue.IsArchived.Should().BeTrue();
+}
+
+[Fact]
+public async Task Handle_AlreadyArchivedIssue_IsIdempotent()
+{
+// Arrange - Create an already archived issue
+var archivedIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Already Archived",
+Description: "Already archived",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow.AddHours(-1))
+{
+IsArchived = true
+};
+
+await _repository.CreateAsync(archivedIssue);
+
+var command = new DeleteIssueCommand { Id = archivedIssue.Id };
+
+// Act - Delete already archived issue (should be idempotent)
+await _handler.Handle(command, CancellationToken.None);
+
+// Assert - Should still be archived
+var dbIssue = await _repository.GetByIdAsync(archivedIssue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.IsArchived.Should().BeTrue();
+}
+
+[Fact]
+public async Task Handle_MultipleIssues_ArchivesOnlySpecifiedIssue()
+{
+// Arrange - Create multiple issues
+var issue1 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue 1",
+Description: "To be archived",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+var issue2 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Issue 2",
+Description: "Should remain active",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(issue1);
+await _repository.CreateAsync(issue2);
+
+var command = new DeleteIssueCommand { Id = issue1.Id };
+
+// Act
+await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+var dbIssue1 = await _repository.GetByIdAsync(issue1.Id);
+var dbIssue2 = await _repository.GetByIdAsync(issue2.Id);
+
+dbIssue1!.IsArchived.Should().BeTrue();
+dbIssue2!.IsArchived.Should().BeFalse();
+}
 }
diff --git a/tests/Integration/Handlers/DeleteIssueHandlerTests.cs b/tests/Integration/Handlers/DeleteIssueHandlerTests.cs
new file mode 100644
index 0000000..71d9027
--- /dev/null
+++ b/tests/Integration/Handlers/DeleteIssueHandlerTests.cs
@@ -0,0 +1,84 @@
+using Shared.Domain;
+
+namespace IssueManager.Tests.Integration.Handlers;
+
+/// <summary>
+/// Integration tests for IssueRepository.ArchiveAsync (soft-delete).
+/// Verifies correct behavior when archiving existing, already-archived, and non-existent issues.
+/// </summary>
+public class DeleteIssueHandlerTests : IAsyncLifetime
+{
+	private const string MONGODB_IMAGE = "mongo:8.0";
+	private const string TEST_DATABASE = "IssueManagerTestDb";
+	private readonly MongoDbContainer _mongoContainer;
+
+	private IIssueRepository _repository = null!;
+
+	public DeleteIssueHandlerTests()
+	{
+		_mongoContainer = new MongoDbBuilder()
+			.WithImage(MONGODB_IMAGE)
+			.Build();
+	}
+
+	/// <summary>
+	/// Initializes the test container and repository.
+	/// </summary>
+	public async Task InitializeAsync()
+	{
+		await _mongoContainer.StartAsync();
+		var connectionString = _mongoContainer.GetConnectionString();
+		_repository = new IssueRepository(connectionString, TEST_DATABASE);
+	}
+
+	/// <summary>
+	/// Disposes the test container.
+	/// </summary>
+	public async Task DisposeAsync()
+	{
+		await _mongoContainer.StopAsync();
+		await _mongoContainer.DisposeAsync();
+	}
+
+	[Fact]
+	public async Task ArchiveAsync_ExistingUnarchivedIssue_ReturnsTrue()
+	{
+		// Arrange
+		var issue = Issue.Create("Test Issue", "Test Description");
+		await _repository.CreateAsync(issue);
+
+		// Act
+		var result = await _repository.ArchiveAsync(issue.Id);
+
+		// Assert
+		result.Should().BeTrue();
+
+		var retrieved = await _repository.GetByIdAsync(issue.Id);
+		retrieved!.IsArchived.Should().BeTrue();
+	}
+
+	[Fact]
+	public async Task ArchiveAsync_AlreadyArchivedIssue_ReturnsTrueIdempotent()
+	{
+		// Arrange
+		var issue = Issue.Create("Already Archived Issue", "Description");
+		await _repository.CreateAsync(issue);
+		await _repository.ArchiveAsync(issue.Id);
+
+		// Act - archive again (already archived, MatchedCount still > 0)
+		var result = await _repository.ArchiveAsync(issue.Id);
+
+		// Assert - should return true (issue was found), not false (issue not found)
+		result.Should().BeTrue();
+	}
+
+	[Fact]
+	public async Task ArchiveAsync_NonExistentIssue_ReturnsFalse()
+	{
+		// Act
+		var result = await _repository.ArchiveAsync("non-existent-id");
+
+		// Assert
+		result.Should().BeFalse();
+	}
+}
diff --git a/tests/Integration/Handlers/GetIssueHandlerTests.cs b/tests/Integration/Handlers/GetIssueHandlerTests.cs
index 7a7e115..2808d98 100644
--- a/tests/Integration/Handlers/GetIssueHandlerTests.cs
+++ b/tests/Integration/Handlers/GetIssueHandlerTests.cs
@@ -1,3 +1,5 @@
+using Shared.Domain;
+
 namespace IssueManager.Tests.Integration.Handlers;
 
 /// <summary>
diff --git a/tests/Integration/Handlers/ListIssuesHandlerIntegrationTests.cs b/tests/Integration/Handlers/ListIssuesHandlerIntegrationTests.cs
index 262975d..0d762b5 100644
--- a/tests/Integration/Handlers/ListIssuesHandlerIntegrationTests.cs
+++ b/tests/Integration/Handlers/ListIssuesHandlerIntegrationTests.cs
@@ -1,7 +1,8 @@
 using FluentAssertions;
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
+using IssueManager.Shared.Validators;
 using Testcontainers.MongoDb;
 
 namespace IssueManager.Tests.Integration.Handlers;
@@ -11,275 +12,289 @@ namespace IssueManager.Tests.Integration.Handlers;
 /// </summary>
 public class ListIssuesHandlerIntegrationTests : IAsyncLifetime
 {
-	private const string MONGODB_IMAGE = "mongo:8.0";
-	private const string TEST_DATABASE = "IssueManagerTestDb";
-	private readonly MongoDbContainer _mongoContainer;
-
-	private IIssueRepository _repository = null!;
-	private ListIssuesHandler _handler = null!;
-
-	public ListIssuesHandlerIntegrationTests()
-	{
-		_mongoContainer = new MongoDbBuilder()
-			.WithImage(MONGODB_IMAGE)
-			.Build();
-	}
-
-	/// <summary>
-	/// Initializes the test container and repository.
-	/// </summary>
-	public async Task InitializeAsync()
-	{
-		await _mongoContainer.StartAsync();
-		var connectionString = _mongoContainer.GetConnectionString();
-		_repository = new IssueRepository(connectionString, TEST_DATABASE);
-		_handler = new ListIssuesHandler(_repository);
-	}
-
-	/// <summary>
-	/// Disposes the test container.
-	/// </summary>
-	public async Task DisposeAsync()
-	{
-		await _mongoContainer.StopAsync();
-		await _mongoContainer.DisposeAsync();
-	}
-
-	[Fact]
-	public async Task Handle_WithPagination_ReturnsCorrectPage()
-	{
-		// Arrange - Create 50 issues
-		for (int i = 0; i < 50; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.Items.Should().HaveCount(20);
-		result.Page.Should().Be(1);
-		result.PageSize.Should().Be(20);
-		result.TotalCount.Should().Be(50);
-		result.TotalPages.Should().Be(3); // 50 / 20 = 2.5 → 3 pages
-	}
-
-	[Fact]
-	public async Task Handle_SecondPage_ReturnsNextSetOfItems()
-	{
-		// Arrange - Create 50 issues
-		for (int i = 0; i < 50; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 2, PageSize = 20 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.Items.Should().HaveCount(20);
-		result.Page.Should().Be(2);
-		result.TotalCount.Should().Be(50);
-	}
-
-	[Fact]
-	public async Task Handle_ExcludesArchivedIssues()
-	{
-		// Arrange - Create 10 issues, archive 3
-		for (int i = 0; i < 10; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i))
-			{
-				IsArchived = i < 3 // Archive first 3 issues
-			};
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.TotalCount.Should().Be(7); // 10 - 3 archived = 7
-		result.Items.Should().HaveCount(7);
-		result.Items.Should().OnlyContain(i => !i.IsArchived);
-	}
-
-	[Fact]
-	public async Task Handle_OrdersByCreatedAtDescending()
-	{
-		// Arrange - Create issues with specific timestamps
-		var issue1 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Oldest Issue",
-			Description: "Created first",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-3));
-
-		var issue2 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Middle Issue",
-			Description: "Created second",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-2));
-
-		var issue3 = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Newest Issue",
-			Description: "Created last",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1));
-
-		await _repository.CreateAsync(issue1);
-		await _repository.CreateAsync(issue2);
-		await _repository.CreateAsync(issue3);
-
-		var query = new ListIssuesQuery { Page = 1, PageSize = 10 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.Items.Should().HaveCount(3);
-		result.Items[0].Title.Should().Be("Newest Issue"); // Newest first
-		result.Items[1].Title.Should().Be("Middle Issue");
-		result.Items[2].Title.Should().Be("Oldest Issue"); // Oldest last
-	}
-
-	[Fact]
-	public async Task Handle_EmptyDatabase_ReturnsEmptyList()
-	{
-		// Arrange - No issues in database
-		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.Items.Should().BeEmpty();
-		result.TotalCount.Should().Be(0);
-		result.TotalPages.Should().Be(0);
-	}
-
-	[Fact]
-	public async Task Handle_LastPagePartial_ReturnsRemainingItems()
-	{
-		// Arrange - Create 42 issues
-		for (int i = 0; i < 42; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 3, PageSize = 20 };
-
-		// Act
-		var result = await _handler.Handle(query, CancellationToken.None);
-
-		// Assert
-		result.Items.Should().HaveCount(2); // 42 - 40 = 2 on last page
-		result.Page.Should().Be(3);
-		result.TotalCount.Should().Be(42);
-		result.TotalPages.Should().Be(3);
-	}
-
-	[Fact]
-	public async Task Handle_LargeDataset_PerformanceUnder1Second()
-	{
-		// Arrange - Create 1000 issues
-		for (int i = 0; i < 1000; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
-
-		// Act
-		var stopwatch = System.Diagnostics.Stopwatch.StartNew();
-		var result = await _handler.Handle(query, CancellationToken.None);
-		stopwatch.Stop();
-
-		// Assert
-		result.Items.Should().HaveCount(20);
-		result.TotalCount.Should().Be(1000);
-		stopwatch.ElapsedMilliseconds.Should().BeLessThan(1000); // < 1 second
-	}
-
-	[Fact]
-	public async Task Handle_ConcurrentCreates_ReturnsConsistentResults()
-	{
-		// Arrange - Create 20 issues
-		for (int i = 0; i < 20; i++)
-		{
-			var issue = new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddMinutes(-i));
-
-			await _repository.CreateAsync(issue);
-		}
-
-		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
-
-		// Act - List while creating new issue
-		var listTask = _handler.Handle(query, CancellationToken.None);
-
-		var newIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Concurrent Issue",
-			Description: "Created during list",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		var createTask = _repository.CreateAsync(newIssue);
-
-		await Task.WhenAll(listTask, createTask);
-
-		var result = await listTask;
-
-		// Assert - List should be consistent (snapshot isolation)
-		result.Items.Should().HaveCount(20);
-		result.TotalCount.Should().BeOneOf(20, 21); // Either before or after concurrent create
-	}
+private const string MONGODB_IMAGE = "mongo:8.0";
+private const string TEST_DATABASE = "IssueManagerTestDb";
+private readonly MongoDbContainer _mongoContainer;
+
+private IIssueRepository _repository = null!;
+private ListIssuesHandler _handler = null!;
+
+public ListIssuesHandlerIntegrationTests()
+{
+_mongoContainer = new MongoDbBuilder()
+.WithImage(MONGODB_IMAGE)
+.Build();
+}
+
+/// <summary>
+/// Initializes the test container and repository.
+/// </summary>
+public async Task InitializeAsync()
+{
+await _mongoContainer.StartAsync();
+var connectionString = _mongoContainer.GetConnectionString();
+_repository = new IssueRepository(connectionString, TEST_DATABASE);
+_handler = new ListIssuesHandler(_repository, new ListIssuesQueryValidator());
+}
+
+/// <summary>
+/// Disposes the test container.
+/// </summary>
+public async Task DisposeAsync()
+{
+await _mongoContainer.StopAsync();
+await _mongoContainer.DisposeAsync();
+}
+
+[Fact]
+public async Task Handle_WithPagination_ReturnsCorrectPage()
+{
+// Arrange - Create 50 issues
+for (int i = 0; i < 50; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Items.Should().HaveCount(20);
+result.Page.Should().Be(1);
+result.PageSize.Should().Be(20);
+result.Total.Should().Be(50);
+result.TotalPages.Should().Be(3); // 50 / 20 = 2.5 → 3 pages
+}
+
+[Fact]
+public async Task Handle_SecondPage_ReturnsNextSetOfItems()
+{
+// Arrange - Create 50 issues
+for (int i = 0; i < 50; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+var query = new ListIssuesQuery { Page = 2, PageSize = 20 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Items.Should().HaveCount(20);
+result.Page.Should().Be(2);
+result.Total.Should().Be(50);
+}
+
+[Fact]
+public async Task Handle_ExcludesArchivedIssues()
+{
+// Arrange - Create 10 issues, archive 3
+var issuesToArchive = new List<string>();
+for (int i = 0; i < 10; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+if (i < 3)
+issuesToArchive.Add(issue.Id);
+}
+
+foreach (var id in issuesToArchive)
+{
+await _repository.ArchiveAsync(id);
+}
+
+var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Total.Should().Be(7); // 10 - 3 archived = 7
+result.Items.Should().HaveCount(7);
+}
+
+[Fact]
+public async Task Handle_OrdersByCreatedAtDescending()
+{
+// Arrange - Create issues with specific timestamps
+var issue1 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Oldest Issue",
+Description: "Created first",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-3),
+UpdatedAt: DateTime.UtcNow.AddDays(-3));
+
+var issue2 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Middle Issue",
+Description: "Created second",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-2),
+UpdatedAt: DateTime.UtcNow.AddDays(-2));
+
+var issue3 = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Newest Issue",
+Description: "Created last",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-1),
+UpdatedAt: DateTime.UtcNow.AddDays(-1));
+
+await _repository.CreateAsync(issue1);
+await _repository.CreateAsync(issue2);
+await _repository.CreateAsync(issue3);
+
+var query = new ListIssuesQuery { Page = 1, PageSize = 10 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Items.Should().HaveCount(3);
+result.Items[0].Title.Should().Be("Newest Issue"); // Newest first
+result.Items[1].Title.Should().Be("Middle Issue");
+result.Items[2].Title.Should().Be("Oldest Issue"); // Oldest last
+}
+
+[Fact]
+public async Task Handle_EmptyDatabase_ReturnsEmptyList()
+{
+// Arrange - No issues in database
+var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Items.Should().BeEmpty();
+result.Total.Should().Be(0);
+result.TotalPages.Should().Be(0);
+}
+
+[Fact]
+public async Task Handle_LastPagePartial_ReturnsRemainingItems()
+{
+// Arrange - Create 42 issues
+for (int i = 0; i < 42; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+var query = new ListIssuesQuery { Page = 3, PageSize = 20 };
+
+// Act
+var result = await _handler.Handle(query, CancellationToken.None);
+
+// Assert
+result.Items.Should().HaveCount(2); // 42 - 40 = 2 on last page
+result.Page.Should().Be(3);
+result.Total.Should().Be(42);
+result.TotalPages.Should().Be(3);
+}
+
+[Fact]
+public async Task Handle_LargeDataset_PerformanceUnder1Second()
+{
+// Arrange - Create 1000 issues
+for (int i = 0; i < 1000; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
+
+// Act
+var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+var result = await _handler.Handle(query, CancellationToken.None);
+stopwatch.Stop();
+
+// Assert
+result.Items.Should().HaveCount(20);
+result.Total.Should().Be(1000);
+stopwatch.ElapsedMilliseconds.Should().BeLessThan(1000); // < 1 second
+}
+
+[Fact]
+public async Task Handle_ConcurrentCreates_ReturnsConsistentResults()
+{
+// Arrange - Create 20 issues
+for (int i = 0; i < 20; i++)
+{
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: $"Issue {i + 1}",
+Description: $"Description {i + 1}",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddMinutes(-i),
+UpdatedAt: DateTime.UtcNow.AddMinutes(-i));
+
+await _repository.CreateAsync(issue);
+}
+
+var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
+
+// Act - List while creating new issue
+var listTask = _handler.Handle(query, CancellationToken.None);
+
+var newIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Concurrent Issue",
+Description: "Created during list",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+var createTask = _repository.CreateAsync(newIssue);
+
+await Task.WhenAll(listTask, createTask);
+
+var result = await listTask;
+
+// Assert - List should be consistent (snapshot isolation)
+result.Items.Should().HaveCount(20);
+result.Total.Should().BeOneOf(20, 21); // Either before or after concurrent create
+}
 }
diff --git a/tests/Integration/Handlers/UpdateIssueHandlerIntegrationTests.cs b/tests/Integration/Handlers/UpdateIssueHandlerIntegrationTests.cs
index ea1f106..11cd50d 100644
--- a/tests/Integration/Handlers/UpdateIssueHandlerIntegrationTests.cs
+++ b/tests/Integration/Handlers/UpdateIssueHandlerIntegrationTests.cs
@@ -1,7 +1,8 @@
 using FluentAssertions;
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
+using global::Shared.Exceptions;
 using IssueManager.Shared.Validators;
 using Testcontainers.MongoDb;
 
@@ -12,235 +13,234 @@ namespace IssueManager.Tests.Integration.Handlers;
 /// </summary>
 public class UpdateIssueHandlerIntegrationTests : IAsyncLifetime
 {
-	private const string MONGODB_IMAGE = "mongo:8.0";
-	private const string TEST_DATABASE = "IssueManagerTestDb";
-	private readonly MongoDbContainer _mongoContainer;
-
-	private IIssueRepository _repository = null!;
-	private UpdateIssueHandler _handler = null!;
-
-	public UpdateIssueHandlerIntegrationTests()
-	{
-		_mongoContainer = new MongoDbBuilder()
-			.WithImage(MONGODB_IMAGE)
-			.Build();
-	}
-
-	/// <summary>
-	/// Initializes the test container and repository.
-	/// </summary>
-	public async Task InitializeAsync()
-	{
-		await _mongoContainer.StartAsync();
-		var connectionString = _mongoContainer.GetConnectionString();
-		_repository = new IssueRepository(connectionString, TEST_DATABASE);
-		_handler = new UpdateIssueHandler(_repository, new UpdateIssueValidator());
-	}
-
-	/// <summary>
-	/// Disposes the test container.
-	/// </summary>
-	public async Task DisposeAsync()
-	{
-		await _mongoContainer.StopAsync();
-		await _mongoContainer.DisposeAsync();
-	}
-
-	[Fact]
-	public async Task Handle_ValidUpdate_UpdatesIssueInDatabase()
-	{
-		// Arrange - Create an issue first
-		var originalIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Original Title",
-			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(originalIssue);
-
-		var command = new UpdateIssueCommand
-		{
-			Id = originalIssue.Id,
-			Title = "Updated Title",
-			Description = "Updated Description"
-		};
-
-		// Act
-		var result = await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		result.Should().NotBeNull();
-		result.Id.Should().Be(originalIssue.Id);
-		result.Title.Should().Be("Updated Title");
-		result.Description.Should().Be("Updated Description");
-		result.UpdatedAt.Should().NotBeNull();
-		result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-
-		// Verify in database
-		var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.Title.Should().Be("Updated Title");
-		dbIssue.Description.Should().Be("Updated Description");
-		dbIssue.UpdatedAt.Should().NotBeNull();
-	}
-
-	[Fact]
-	public async Task Handle_UpdateTimestamp_SetsToCurrentTime()
-	{
-		// Arrange
-		var originalIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Original Title",
-			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
-		{
-			UpdatedAt = DateTime.UtcNow.AddHours(-5)
-		};
-
-		await _repository.CreateAsync(originalIssue);
-
-		var command = new UpdateIssueCommand
-		{
-			Id = originalIssue.Id,
-			Title = "New Title",
-			Description = "New Description"
-		};
-
-		// Act
-		var result = await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		result.UpdatedAt.Should().NotBeNull();
-		result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-		result.UpdatedAt.Should().BeAfter(originalIssue.UpdatedAt!.Value);
-
-		// Verify in database
-		var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
-		dbIssue!.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-	}
-
-	[Fact]
-	public async Task Handle_AtomicUpdate_TitleAndDescriptionBothUpdate()
-	{
-		// Arrange
-		var originalIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Original Title",
-			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(originalIssue);
-
-		var command = new UpdateIssueCommand
-		{
-			Id = originalIssue.Id,
-			Title = "New Title",
-			Description = "New Description"
-		};
-
-		// Act
-		var result = await _handler.Handle(command, CancellationToken.None);
-
-		// Assert - Both fields should be updated atomically
-		var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.Title.Should().Be("New Title");
-		dbIssue.Description.Should().Be("New Description");
-	}
-
-	[Fact]
-	public async Task Handle_NonExistentIssue_ThrowsNotFoundException()
-	{
-		// Arrange
-		var nonExistentId = Guid.NewGuid().ToString();
-		var command = new UpdateIssueCommand
-		{
-			Id = nonExistentId,
-			Title = "Title",
-			Description = "Description"
-		};
-
-		// Act
-		Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		await act.Should().ThrowAsync<NotFoundException>();
-	}
-
-	[Fact]
-	public async Task Handle_ConcurrentUpdates_LastWriteWins()
-	{
-		// Arrange - Create an issue
-		var issue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Original Title",
-			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow);
-
-		await _repository.CreateAsync(issue);
-
-		var command1 = new UpdateIssueCommand
-		{
-			Id = issue.Id,
-			Title = "First Update",
-			Description = "First Description"
-		};
-
-		var command2 = new UpdateIssueCommand
-		{
-			Id = issue.Id,
-			Title = "Second Update",
-			Description = "Second Description"
-		};
-
-		// Act - Simulate concurrent updates
-		var result1 = await _handler.Handle(command1, CancellationToken.None);
-		await Task.Delay(100); // Small delay to ensure different timestamp
-		var result2 = await _handler.Handle(command2, CancellationToken.None);
-
-		// Assert - Last write wins
-		var dbIssue = await _repository.GetByIdAsync(issue.Id);
-		dbIssue.Should().NotBeNull();
-		dbIssue!.Title.Should().Be("Second Update");
-		dbIssue.Description.Should().Be("Second Description");
-		dbIssue.UpdatedAt.Should().BeAfter(result1.UpdatedAt!.Value);
-	}
-
-	[Fact]
-	public async Task Handle_ArchivedIssue_ThrowsConflictException()
-	{
-		// Arrange - Create and archive an issue
-		var archivedIssue = new Issue(
-			Id: Guid.NewGuid().ToString(),
-			Title: "Archived Issue",
-			Description: "This is archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow)
-		{
-			IsArchived = true
-		};
-
-		await _repository.CreateAsync(archivedIssue);
-
-		var command = new UpdateIssueCommand
-		{
-			Id = archivedIssue.Id,
-			Title = "Attempt Update",
-			Description = "Should fail"
-		};
-
-		// Act
-		Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
-
-		// Assert
-		await act.Should().ThrowAsync<ConflictException>();
-
-		// Verify issue wasn't updated
-		var dbIssue = await _repository.GetByIdAsync(archivedIssue.Id);
-		dbIssue!.Title.Should().Be("Archived Issue");
-	}
+private const string MONGODB_IMAGE = "mongo:8.0";
+private const string TEST_DATABASE = "IssueManagerTestDb";
+private readonly MongoDbContainer _mongoContainer;
+
+private IIssueRepository _repository = null!;
+private UpdateIssueHandler _handler = null!;
+
+public UpdateIssueHandlerIntegrationTests()
+{
+_mongoContainer = new MongoDbBuilder()
+.WithImage(MONGODB_IMAGE)
+.Build();
+}
+
+/// <summary>
+/// Initializes the test container and repository.
+/// </summary>
+public async Task InitializeAsync()
+{
+await _mongoContainer.StartAsync();
+var connectionString = _mongoContainer.GetConnectionString();
+_repository = new IssueRepository(connectionString, TEST_DATABASE);
+_handler = new UpdateIssueHandler(_repository, new UpdateIssueValidator());
+}
+
+/// <summary>
+/// Disposes the test container.
+/// </summary>
+public async Task DisposeAsync()
+{
+await _mongoContainer.StopAsync();
+await _mongoContainer.DisposeAsync();
+}
+
+[Fact]
+public async Task Handle_ValidUpdate_UpdatesIssueInDatabase()
+{
+// Arrange - Create an issue first
+var originalIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Original Title",
+Description: "Original Description",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(originalIssue);
+
+var command = new UpdateIssueCommand
+{
+Id = originalIssue.Id,
+Title = "Updated Title",
+Description = "Updated Description"
+};
+
+// Act
+var result = await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+result.Should().NotBeNull();
+result.Id.Should().Be(originalIssue.Id);
+result.Title.Should().Be("Updated Title");
+result.Description.Should().Be("Updated Description");
+result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
+
+// Verify in database
+var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.Title.Should().Be("Updated Title");
+dbIssue.Description.Should().Be("Updated Description");
+}
+
+[Fact]
+public async Task Handle_UpdateTimestamp_SetsToCurrentTime()
+{
+// Arrange
+var originalIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Original Title",
+Description: "Original Description",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow.AddDays(-1),
+UpdatedAt: DateTime.UtcNow.AddHours(-5));
+
+await _repository.CreateAsync(originalIssue);
+
+var command = new UpdateIssueCommand
+{
+Id = originalIssue.Id,
+Title = "New Title",
+Description = "New Description"
+};
+
+// Act
+var result = await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
+result.UpdatedAt.Should().BeAfter(originalIssue.UpdatedAt);
+
+// Verify in database
+var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
+dbIssue!.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
+}
+
+[Fact]
+public async Task Handle_AtomicUpdate_TitleAndDescriptionBothUpdate()
+{
+// Arrange
+var originalIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Original Title",
+Description: "Original Description",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(originalIssue);
+
+var command = new UpdateIssueCommand
+{
+Id = originalIssue.Id,
+Title = "New Title",
+Description = "New Description"
+};
+
+// Act
+var result = await _handler.Handle(command, CancellationToken.None);
+
+// Assert - Both fields should be updated atomically
+var dbIssue = await _repository.GetByIdAsync(originalIssue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.Title.Should().Be("New Title");
+dbIssue.Description.Should().Be("New Description");
+}
+
+[Fact]
+public async Task Handle_NonExistentIssue_ThrowsNotFoundException()
+{
+// Arrange
+var nonExistentId = Guid.NewGuid().ToString();
+var command = new UpdateIssueCommand
+{
+Id = nonExistentId,
+Title = "Title",
+Description = "Description"
+};
+
+// Act
+Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+await act.Should().ThrowAsync<NotFoundException>();
+}
+
+[Fact]
+public async Task Handle_ConcurrentUpdates_LastWriteWins()
+{
+// Arrange - Create an issue
+var issue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Original Title",
+Description: "Original Description",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow);
+
+await _repository.CreateAsync(issue);
+
+var command1 = new UpdateIssueCommand
+{
+Id = issue.Id,
+Title = "First Update",
+Description = "First Description"
+};
+
+var command2 = new UpdateIssueCommand
+{
+Id = issue.Id,
+Title = "Second Update",
+Description = "Second Description"
+};
+
+// Act - Simulate concurrent updates
+var result1 = await _handler.Handle(command1, CancellationToken.None);
+await Task.Delay(100); // Small delay to ensure different timestamp
+var result2 = await _handler.Handle(command2, CancellationToken.None);
+
+// Assert - Last write wins
+var dbIssue = await _repository.GetByIdAsync(issue.Id);
+dbIssue.Should().NotBeNull();
+dbIssue!.Title.Should().Be("Second Update");
+dbIssue.Description.Should().Be("Second Description");
+dbIssue.UpdatedAt.Should().BeAfter(result1.UpdatedAt);
+}
+
+[Fact]
+public async Task Handle_ArchivedIssue_ThrowsConflictException()
+{
+// Arrange - Create and archive an issue
+var archivedIssue = new Issue(
+Id: Guid.NewGuid().ToString(),
+Title: "Archived Issue",
+Description: "This is archived",
+Status: IssueStatus.Open,
+CreatedAt: DateTime.UtcNow,
+UpdatedAt: DateTime.UtcNow)
+{
+IsArchived = true
+};
+
+await _repository.CreateAsync(archivedIssue);
+
+var command = new UpdateIssueCommand
+{
+Id = archivedIssue.Id,
+Title = "Attempt Update",
+Description = "Should fail"
+};
+
+// Act
+Func<Task> act = async () => await _handler.Handle(command, CancellationToken.None);
+
+// Assert
+await act.Should().ThrowAsync<ConflictException>();
+
+// Verify issue wasn't updated
+var dbIssue = await _repository.GetByIdAsync(archivedIssue.Id);
+dbIssue!.Title.Should().Be("Archived Issue");
+}
 }
diff --git a/tests/Integration/Handlers/UpdateIssueStatusHandlerTests.cs b/tests/Integration/Handlers/UpdateIssueStatusHandlerTests.cs
index c522be9..2cc8f09 100644
--- a/tests/Integration/Handlers/UpdateIssueStatusHandlerTests.cs
+++ b/tests/Integration/Handlers/UpdateIssueStatusHandlerTests.cs
@@ -1,3 +1,6 @@
+using Shared.Domain;
+using Shared.Validators;
+
 namespace IssueManager.Tests.Integration.Handlers;
 
 /// <summary>
diff --git a/tests/Unit/Builders/IssueBuilder.cs b/tests/Unit/Builders/IssueBuilder.cs
index 87ce512..ca79034 100644
--- a/tests/Unit/Builders/IssueBuilder.cs
+++ b/tests/Unit/Builders/IssueBuilder.cs
@@ -1,4 +1,4 @@
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
 
 namespace IssueManager.Tests.Unit.Builders;
 
@@ -10,14 +10,10 @@ public class IssueBuilder
 	private string _id = Guid.NewGuid().ToString();
 	private string _title = "Default Test Issue";
 	private string _description = "Default test description";
-	private string _authorId = "test-user-123";
+	private IssueStatus _status = IssueStatus.Open;
 	private DateTime _createdAt = DateTime.UtcNow;
-	private DateTime? _updatedAt;
+	private DateTime _updatedAt = DateTime.UtcNow;
 	private bool _isArchived;
-	private string? _categoryId;
-	private string? _statusId;
-	private bool _approvedForRelease;
-	private bool _rejected;
 
 	/// <summary>
 	/// Sets the issue ID.
@@ -47,11 +43,11 @@ public IssueBuilder WithDescription(string description)
 	}
 
 	/// <summary>
-	/// Sets the author ID.
+	/// Sets the issue status.
 	/// </summary>
-	public IssueBuilder WithAuthorId(string authorId)
+	public IssueBuilder WithStatus(IssueStatus status)
 	{
-		_authorId = authorId;
+		_status = status;
 		return this;
 	}
 
@@ -67,7 +63,7 @@ public IssueBuilder WithCreatedAt(DateTime createdAt)
 	/// <summary>
 	/// Sets the updated at timestamp.
 	/// </summary>
-	public IssueBuilder WithUpdatedAt(DateTime? updatedAt)
+	public IssueBuilder WithUpdatedAt(DateTime updatedAt)
 	{
 		_updatedAt = updatedAt;
 		return this;
@@ -91,42 +87,6 @@ public IssueBuilder AsActive()
 		return this;
 	}
 
-	/// <summary>
-	/// Sets the category ID.
-	/// </summary>
-	public IssueBuilder WithCategoryId(string? categoryId)
-	{
-		_categoryId = categoryId;
-		return this;
-	}
-
-	/// <summary>
-	/// Sets the status ID.
-	/// </summary>
-	public IssueBuilder WithStatusId(string? statusId)
-	{
-		_statusId = statusId;
-		return this;
-	}
-
-	/// <summary>
-	/// Marks the issue as approved for release.
-	/// </summary>
-	public IssueBuilder AsApprovedForRelease()
-	{
-		_approvedForRelease = true;
-		return this;
-	}
-
-	/// <summary>
-	/// Marks the issue as rejected.
-	/// </summary>
-	public IssueBuilder AsRejected()
-	{
-		_rejected = true;
-		return this;
-	}
-
 	/// <summary>
 	/// Builds the Issue instance.
 	/// </summary>
@@ -136,15 +96,11 @@ public Issue Build()
 			Id: _id,
 			Title: _title,
 			Description: _description,
-			AuthorId: _authorId,
-			CreatedAt: _createdAt)
+			Status: _status,
+			CreatedAt: _createdAt,
+			UpdatedAt: _updatedAt)
 		{
-			UpdatedAt = _updatedAt,
-			IsArchived = _isArchived,
-			CategoryId = _categoryId,
-			StatusId = _statusId,
-			ApprovedForRelease = _approvedForRelease,
-			Rejected = _rejected
+			IsArchived = _isArchived
 		};
 	}
 
@@ -159,7 +115,7 @@ public Issue Build()
 	public static IssueBuilder Archived() => new IssueBuilder().AsArchived();
 
 	/// <summary>
-	/// Creates an issue builder with a specific title.
+	/// Creates a closed issue builder.
 	/// </summary>
-	public static IssueBuilder WithTitle(string title) => new IssueBuilder().WithTitle(title);
+	public static IssueBuilder Closed() => new IssueBuilder().WithStatus(IssueStatus.Closed);
 }
diff --git a/tests/Unit/Domain/IssueTests.cs b/tests/Unit/Domain/IssueTests.cs
index 64d5bc1..cf6dc48 100644
--- a/tests/Unit/Domain/IssueTests.cs
+++ b/tests/Unit/Domain/IssueTests.cs
@@ -1,5 +1,6 @@
 using FluentAssertions;
-using IssueManager.Shared.Domain;
+
+using Shared.Domain;
 
 namespace IssueManager.Tests.Unit.Domain;
 
diff --git a/tests/Unit/Domain/LabelTests.cs b/tests/Unit/Domain/LabelTests.cs
index b6ae8ca..fc6bb62 100644
--- a/tests/Unit/Domain/LabelTests.cs
+++ b/tests/Unit/Domain/LabelTests.cs
@@ -1,5 +1,6 @@
 using FluentAssertions;
-using IssueManager.Shared.Domain;
+
+using Shared.Domain;
 
 namespace IssueManager.Tests.Unit.Domain;
 
diff --git a/tests/Unit/Handlers/DeleteIssueHandlerTests.cs b/tests/Unit/Handlers/DeleteIssueHandlerTests.cs
index 1e59eb7..739d96e 100644
--- a/tests/Unit/Handlers/DeleteIssueHandlerTests.cs
+++ b/tests/Unit/Handlers/DeleteIssueHandlerTests.cs
@@ -1,7 +1,10 @@
 using FluentAssertions;
+using FluentValidation;
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
+using global::Shared.Exceptions;
+using IssueManager.Shared.Validators;
 using NSubstitute;
 
 namespace IssueManager.Tests.Unit.Handlers;
@@ -17,7 +20,7 @@ public class DeleteIssueHandlerTests
 	public DeleteIssueHandlerTests()
 	{
 		_repository = Substitute.For<IIssueRepository>();
-		_handler = new DeleteIssueHandler(_repository);
+		_handler = new DeleteIssueHandler(_repository, new DeleteIssueValidator());
 	}
 
 	[Fact]
@@ -29,8 +32,9 @@ public async Task Handle_ValidIssue_SetsIsArchivedToTrue()
 			Id: issueId,
 			Title: "Issue to Delete",
 			Description: "This will be archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddDays(-1))
 		{
 			IsArchived = false
 		};
@@ -40,23 +44,15 @@ public async Task Handle_ValidIssue_SetsIsArchivedToTrue()
 		_repository.GetByIdAsync(issueId, Arg.Any<CancellationToken>())
 			.Returns(existingIssue);
 
-		var archivedIssue = existingIssue with
-		{
-			IsArchived = true,
-			UpdatedAt = DateTime.UtcNow
-		};
-
-		_repository.UpdateAsync(Arg.Any<Issue>(), Arg.Any<CancellationToken>())
-			.Returns(archivedIssue);
+		_repository.ArchiveAsync(issueId, Arg.Any<CancellationToken>())
+			.Returns(true);
 
 		// Act
 		await _handler.Handle(command, CancellationToken.None);
 
 		// Assert
 		await _repository.Received(1).GetByIdAsync(issueId, Arg.Any<CancellationToken>());
-		await _repository.Received(1).UpdateAsync(
-			Arg.Is<Issue>(i => i.IsArchived == true && i.Id == issueId),
-			Arg.Any<CancellationToken>());
+		await _repository.Received(1).ArchiveAsync(issueId, Arg.Any<CancellationToken>());
 	}
 
 	[Fact]
@@ -86,11 +82,11 @@ public async Task Handle_AlreadyArchivedIssue_IsIdempotent()
 			Id: issueId,
 			Title: "Already Archived",
 			Description: "Already archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddHours(-1))
 		{
-			IsArchived = true,
-			UpdatedAt = DateTime.UtcNow.AddHours(-1)
+			IsArchived = true
 		};
 
 		var command = new DeleteIssueCommand { Id = issueId };
@@ -98,17 +94,16 @@ public async Task Handle_AlreadyArchivedIssue_IsIdempotent()
 		_repository.GetByIdAsync(issueId, Arg.Any<CancellationToken>())
 			.Returns(archivedIssue);
 
-		// Act & Assert - Should be idempotent (either succeed silently or throw)
-		// Decision: Return success (204) without updating (idempotent)
+		// Act — should succeed idempotently without calling ArchiveAsync
 		await _handler.Handle(command, CancellationToken.None);
 
 		await _repository.Received(1).GetByIdAsync(issueId, Arg.Any<CancellationToken>());
-		// Should NOT call UpdateAsync since already archived
-		await _repository.DidNotReceive().UpdateAsync(Arg.Any<Issue>(), Arg.Any<CancellationToken>());
+		// Should NOT call ArchiveAsync since already archived
+		await _repository.DidNotReceive().ArchiveAsync(Arg.Any<string>(), Arg.Any<CancellationToken>());
 	}
 
 	[Fact]
-	public async Task Handle_ValidIssue_UpdatesTimestamp()
+	public async Task Handle_ValidIssue_CallsArchive()
 	{
 		// Arrange
 		var issueId = Guid.NewGuid().ToString();
@@ -116,11 +111,11 @@ public async Task Handle_ValidIssue_UpdatesTimestamp()
 			Id: issueId,
 			Title: "Issue to Delete",
 			Description: "This will be archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddHours(-2))
 		{
-			IsArchived = false,
-			UpdatedAt = DateTime.UtcNow.AddHours(-2)
+			IsArchived = false
 		};
 
 		var command = new DeleteIssueCommand { Id = issueId };
@@ -128,22 +123,15 @@ public async Task Handle_ValidIssue_UpdatesTimestamp()
 		_repository.GetByIdAsync(issueId, Arg.Any<CancellationToken>())
 			.Returns(existingIssue);
 
-		var archivedIssue = existingIssue with
-		{
-			IsArchived = true,
-			UpdatedAt = DateTime.UtcNow
-		};
-
-		_repository.UpdateAsync(Arg.Any<Issue>(), Arg.Any<CancellationToken>())
-			.Returns(archivedIssue);
+		_repository.ArchiveAsync(issueId, Arg.Any<CancellationToken>())
+			.Returns(true);
 
 		// Act
-		await _handler.Handle(command, CancellationToken.None);
+		var result = await _handler.Handle(command, CancellationToken.None);
 
 		// Assert
-		await _repository.Received(1).UpdateAsync(
-			Arg.Is<Issue>(i => i.UpdatedAt != null && i.UpdatedAt > existingIssue.UpdatedAt),
-			Arg.Any<CancellationToken>());
+		result.Should().BeTrue();
+		await _repository.Received(1).ArchiveAsync(issueId, Arg.Any<CancellationToken>());
 	}
 
 	[Fact]
diff --git a/tests/Unit/Handlers/ListIssuesHandlerTests.cs b/tests/Unit/Handlers/ListIssuesHandlerTests.cs
index d2c1625..09baea6 100644
--- a/tests/Unit/Handlers/ListIssuesHandlerTests.cs
+++ b/tests/Unit/Handlers/ListIssuesHandlerTests.cs
@@ -1,7 +1,13 @@
 using FluentAssertions;
+
+using FluentValidation;
+
+using global::Shared.Domain;
+
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using IssueManager.Shared.Validators;
+
 using NSubstitute;
 
 namespace IssueManager.Tests.Unit.Handlers;
@@ -17,7 +23,7 @@ public class ListIssuesHandlerTests
 	public ListIssuesHandlerTests()
 	{
 		_repository = Substitute.For<IIssueRepository>();
-		_handler = new ListIssuesHandler(_repository);
+		_handler = new ListIssuesHandler(_repository, new ListIssuesQueryValidator());
 	}
 
 	[Fact]
@@ -27,11 +33,8 @@ public async Task Handle_DefaultPagination_ReturnsFirstPageWithCorrectMetadata()
 		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
 
 		var issues = GenerateIssues(20);
-		_repository.GetAllAsync(1, 20, false, Arg.Any<CancellationToken>())
-			.Returns(issues);
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(42);
+		_repository.GetAllAsync(1, 20, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)issues, 42L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -40,7 +43,7 @@ public async Task Handle_DefaultPagination_ReturnsFirstPageWithCorrectMetadata()
 		result.Items.Should().HaveCount(20);
 		result.Page.Should().Be(1);
 		result.PageSize.Should().Be(20);
-		result.TotalCount.Should().Be(42);
+		result.Total.Should().Be(42);
 		result.TotalPages.Should().Be(3); // 42 / 20 = 2.1 → 3 pages
 	}
 
@@ -51,11 +54,8 @@ public async Task Handle_SecondPage_ReturnsCorrectItems()
 		var query = new ListIssuesQuery { Page = 2, PageSize = 10 };
 
 		var issues = GenerateIssues(10);
-		_repository.GetAllAsync(2, 10, false, Arg.Any<CancellationToken>())
-			.Returns(issues);
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(42);
+		_repository.GetAllAsync(2, 10, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)issues, 42L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -64,7 +64,7 @@ public async Task Handle_SecondPage_ReturnsCorrectItems()
 		result.Items.Should().HaveCount(10);
 		result.Page.Should().Be(2);
 		result.PageSize.Should().Be(10);
-		result.TotalCount.Should().Be(42);
+		result.Total.Should().Be(42);
 		result.TotalPages.Should().Be(5); // 42 / 10 = 4.2 → 5 pages
 	}
 
@@ -75,11 +75,8 @@ public async Task Handle_LastPagePartialItems_ReturnsCorrectCount()
 		var query = new ListIssuesQuery { Page = 3, PageSize = 20 };
 
 		var issues = GenerateIssues(2); // Last page has only 2 items
-		_repository.GetAllAsync(3, 20, false, Arg.Any<CancellationToken>())
-			.Returns(issues);
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(42);
+		_repository.GetAllAsync(3, 20, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)issues, 42L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -88,7 +85,7 @@ public async Task Handle_LastPagePartialItems_ReturnsCorrectCount()
 		result.Items.Should().HaveCount(2);
 		result.Page.Should().Be(3);
 		result.PageSize.Should().Be(20);
-		result.TotalCount.Should().Be(42);
+		result.Total.Should().Be(42);
 		result.TotalPages.Should().Be(3);
 	}
 
@@ -98,11 +95,8 @@ public async Task Handle_EmptyResult_ReturnsEmptyList()
 		// Arrange
 		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
 
-		_repository.GetAllAsync(1, 20, false, Arg.Any<CancellationToken>())
-			.Returns(new List<Issue>());
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(0);
+		_repository.GetAllAsync(1, 20, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)new List<Issue>(), 0L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -111,7 +105,7 @@ public async Task Handle_EmptyResult_ReturnsEmptyList()
 		result.Items.Should().BeEmpty();
 		result.Page.Should().Be(1);
 		result.PageSize.Should().Be(20);
-		result.TotalCount.Should().Be(0);
+		result.Total.Should().Be(0);
 		result.TotalPages.Should().Be(0);
 	}
 
@@ -121,11 +115,8 @@ public async Task Handle_PageExceedsTotalPages_ReturnsEmptyList()
 		// Arrange
 		var query = new ListIssuesQuery { Page = 10, PageSize = 20 };
 
-		_repository.GetAllAsync(10, 20, false, Arg.Any<CancellationToken>())
-			.Returns(new List<Issue>());
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(42); // Only 3 pages exist
+		_repository.GetAllAsync(10, 20, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)new List<Issue>(), 42L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -147,7 +138,7 @@ public async Task Handle_InvalidPage_ThrowsValidationException()
 
 		// Assert
 		await act.Should().ThrowAsync<ValidationException>()
-			.WithMessage("*Page*greater than 0*");
+		.WithMessage("*Page*greater than or equal to 1*");
 	}
 
 	[Fact]
@@ -161,7 +152,7 @@ public async Task Handle_InvalidPageSize_ThrowsValidationException()
 
 		// Assert
 		await act.Should().ThrowAsync<ValidationException>()
-			.WithMessage("*PageSize*greater than 0*");
+		.WithMessage("*Page size*between 1 and 100*");
 	}
 
 	[Fact]
@@ -175,7 +166,7 @@ public async Task Handle_PageSizeExceedsMax_ThrowsValidationException()
 
 		// Assert
 		await act.Should().ThrowAsync<ValidationException>()
-			.WithMessage("*PageSize*100*");
+		.WithMessage("*Page size*between 1 and 100*");
 	}
 
 	[Fact]
@@ -185,17 +176,14 @@ public async Task Handle_ExcludesArchivedIssues_ByDefault()
 		var query = new ListIssuesQuery { Page = 1, PageSize = 20 };
 
 		var issues = GenerateIssues(10);
-		_repository.GetAllAsync(1, 20, false, Arg.Any<CancellationToken>())
-			.Returns(issues);
-
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(10);
+		_repository.GetAllAsync(1, 20, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)issues, 10L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
 
 		// Assert
-		await _repository.Received(1).GetAllAsync(1, 20, false, Arg.Any<CancellationToken>());
+		await _repository.Received(1).GetAllAsync(1, 20, Arg.Any<CancellationToken>());
 		result.Items.Should().HaveCount(10);
 	}
 
@@ -205,18 +193,16 @@ public async Task Handle_OrdersByCreatedAtDescending_NewestFirst()
 		// Arrange
 		var query = new ListIssuesQuery { Page = 1, PageSize = 3 };
 
-		var issues = new List<Issue>
-		{
-			new("1", "Issue 1", "Desc", "user1", DateTime.UtcNow.AddDays(-3)),
-			new("2", "Issue 2", "Desc", "user2", DateTime.UtcNow.AddDays(-2)),
-			new("3", "Issue 3", "Desc", "user3", DateTime.UtcNow.AddDays(-1))
-		};
-
-		_repository.GetAllAsync(1, 3, false, Arg.Any<CancellationToken>())
-			.Returns(issues.OrderByDescending(i => i.CreatedAt).ToList());
+		// Create issues already in expected descending order (newest first)
+		var orderedIssues = new List<Issue>
+{
+new("3", "Issue 3", "Desc", IssueStatus.Open, DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(-1)),
+new("2", "Issue 2", "Desc", IssueStatus.Open, DateTime.UtcNow.AddDays(-2), DateTime.UtcNow.AddDays(-2)),
+new("1", "Issue 1", "Desc", IssueStatus.Open, DateTime.UtcNow.AddDays(-3), DateTime.UtcNow.AddDays(-3))
+};
 
-		_repository.CountAsync(false, Arg.Any<CancellationToken>())
-			.Returns(3);
+		_repository.GetAllAsync(1, 3, Arg.Any<CancellationToken>())
+		.Returns(((IReadOnlyList<Issue>)orderedIssues, 3L));
 
 		// Act
 		var result = await _handler.Handle(query, CancellationToken.None);
@@ -234,11 +220,12 @@ private static List<Issue> GenerateIssues(int count)
 		for (int i = 0; i < count; i++)
 		{
 			issues.Add(new Issue(
-				Id: Guid.NewGuid().ToString(),
-				Title: $"Issue {i + 1}",
-				Description: $"Description {i + 1}",
-				AuthorId: "user-123",
-				CreatedAt: DateTime.UtcNow.AddDays(-i)));
+			Id: Guid.NewGuid().ToString(),
+			Title: $"Issue {i + 1}",
+			Description: $"Description {i + 1}",
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-i),
+			UpdatedAt: DateTime.UtcNow.AddDays(-i)));
 		}
 		return issues;
 	}
diff --git a/tests/Unit/Handlers/UpdateIssueHandlerTests.cs b/tests/Unit/Handlers/UpdateIssueHandlerTests.cs
index c4524ef..108a67a 100644
--- a/tests/Unit/Handlers/UpdateIssueHandlerTests.cs
+++ b/tests/Unit/Handlers/UpdateIssueHandlerTests.cs
@@ -1,7 +1,8 @@
 using FluentAssertions;
 using IssueManager.Api.Data;
 using IssueManager.Api.Handlers;
-using IssueManager.Shared.Domain.Models;
+using global::Shared.Domain;
+using global::Shared.Exceptions;
 using IssueManager.Shared.Validators;
 using NSubstitute;
 
@@ -32,11 +33,9 @@ public async Task Handle_ValidCommand_ReturnsUpdatedIssue()
 			Id: issueId,
 			Title: "Original Title",
 			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
-		{
-			UpdatedAt = DateTime.UtcNow.AddDays(-1)
-		};
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddDays(-1));
 
 		var command = new UpdateIssueCommand
 		{
@@ -65,7 +64,7 @@ public async Task Handle_ValidCommand_ReturnsUpdatedIssue()
 		result.Should().NotBeNull();
 		result.Title.Should().Be("Updated Title");
 		result.Description.Should().Be("Updated Description");
-		result.UpdatedAt.Should().NotBeNull();
+		result.UpdatedAt.Should().BeAfter(DateTime.MinValue);
 		result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
 
 		await _repository.Received(1).GetByIdAsync(issueId, Arg.Any<CancellationToken>());
@@ -163,8 +162,9 @@ public async Task Handle_ArchivedIssue_ThrowsConflictException()
 			Id: issueId,
 			Title: "Archived Issue",
 			Description: "This is archived",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddDays(-1))
 		{
 			IsArchived = true
 		};
@@ -196,11 +196,9 @@ public async Task Handle_IdempotentUpdate_UpdatesTimestamp()
 			Id: issueId,
 			Title: "Same Title",
 			Description: "Same Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1))
-		{
-			UpdatedAt = DateTime.UtcNow.AddHours(-1)
-		};
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddHours(-1));
 
 		var command = new UpdateIssueCommand
 		{
@@ -221,9 +219,9 @@ public async Task Handle_IdempotentUpdate_UpdatesTimestamp()
 		var result = await _handler.Handle(command, CancellationToken.None);
 
 		// Assert
-		result.UpdatedAt.Should().NotBeNull();
+		result.UpdatedAt.Should().BeAfter(DateTime.MinValue);
 		result.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(2));
-		result.UpdatedAt.Should().BeAfter(existingIssue.UpdatedAt!.Value);
+		result.UpdatedAt.Should().BeAfter(existingIssue.UpdatedAt);
 	}
 
 	[Fact]
@@ -235,8 +233,9 @@ public async Task Handle_NullDescription_AllowsNullValue()
 			Id: issueId,
 			Title: "Original Title",
 			Description: "Original Description",
-			AuthorId: "user-123",
-			CreatedAt: DateTime.UtcNow.AddDays(-1));
+			Status: IssueStatus.Open,
+			CreatedAt: DateTime.UtcNow.AddDays(-1),
+			UpdatedAt: DateTime.UtcNow.AddDays(-1));
 
 		var command = new UpdateIssueCommand
 		{
diff --git a/tests/Unit/Validators/CreateIssueValidatorTests.cs b/tests/Unit/Validators/CreateIssueValidatorTests.cs
index e597002..dcf403e 100644
--- a/tests/Unit/Validators/CreateIssueValidatorTests.cs
+++ b/tests/Unit/Validators/CreateIssueValidatorTests.cs
@@ -1,5 +1,6 @@
 using FluentAssertions;
-using IssueManager.Shared.Validators;
+
+using Shared.Validators;
 
 namespace IssueManager.Tests.Unit.Validators;
 
diff --git a/tests/Unit/Validators/ListIssuesQueryValidatorTests.cs b/tests/Unit/Validators/ListIssuesQueryValidatorTests.cs
index 8e32400..92512fa 100644
--- a/tests/Unit/Validators/ListIssuesQueryValidatorTests.cs
+++ b/tests/Unit/Validators/ListIssuesQueryValidatorTests.cs
@@ -62,7 +62,7 @@ public void ListIssuesQueryValidator_PageZero_ReturnsValidationError()
 		result.IsValid.Should().BeFalse();
 		result.Errors.Should().HaveCount(1);
 		result.Errors[0].PropertyName.Should().Be("Page");
-		result.Errors[0].ErrorMessage.Should().Contain("greater than 0");
+		result.Errors[0].ErrorMessage.Should().Contain("greater than or equal to 1");
 	}
 
 	[Fact]
@@ -100,7 +100,7 @@ public void ListIssuesQueryValidator_PageSizeZero_ReturnsValidationError()
 		result.IsValid.Should().BeFalse();
 		result.Errors.Should().HaveCount(1);
 		result.Errors[0].PropertyName.Should().Be("PageSize");
-		result.Errors[0].ErrorMessage.Should().Contain("greater than 0");
+		result.Errors[0].ErrorMessage.Should().Contain("between 1 and 100");
 	}
 
 	[Fact]
diff --git a/tests/Unit/Validators/UpdateIssueStatusValidatorTests.cs b/tests/Unit/Validators/UpdateIssueStatusValidatorTests.cs
index 6436689..39e2b40 100644
--- a/tests/Unit/Validators/UpdateIssueStatusValidatorTests.cs
+++ b/tests/Unit/Validators/UpdateIssueStatusValidatorTests.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
-using IssueManager.Shared.Domain;
-using IssueManager.Shared.Validators;
+
+using Shared.Domain;
+using Shared.Validators;
 
 namespace IssueManager.Tests.Unit.Validators;