diff --git a/application/tests/review_queue_test.py b/application/tests/review_queue_test.py
new file mode 100644
index 000000000..4136c80a1
--- /dev/null
+++ b/application/tests/review_queue_test.py
@@ -0,0 +1,168 @@
+"""
+Unit tests for HITL Review Queue and API endpoints.
+
+Tests cover:
+- Queue management
+- Review logging
+- JSONL persistence
+- API endpoints
+- Error handling
+"""
+
+import json
+import tempfile
+import unittest
+from unittest.mock import patch
+from pathlib import Path
+
+from application.utils.review_queue import ReviewQueue
+
+
+class TestReviewQueue(unittest.TestCase):
+    """Test suite for ReviewQueue class."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.queue = ReviewQueue(log_dir=self.temp_dir)
+
+    def tearDown(self):
+        """Clean up test files."""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_add_to_queue(self):
+        """Test adding content to queue."""
+        result = self.queue.add_to_queue(
+            "test1", "Sample content", "OWASP/ASVS"
+        )
+        self.assertTrue(result)
+        self.assertEqual(len(self.queue.queue), 1)
+        self.assertEqual(self.queue.stats["pending"], 1)
+
+    def test_add_multiple_items(self):
+        """Test adding multiple items."""
+        self.queue.add_to_queue("test1", "Content 1", "OWASP/ASVS")
+        self.queue.add_to_queue("test2", "Content 2", "OWASP/wstg")
+        self.queue.add_to_queue("test3", "Content 3", "OWASP/API")
+
+        self.assertEqual(len(self.queue.queue), 3)
+        self.assertEqual(self.queue.stats["pending"], 3)
+
+    def test_submit_review_approved(self):
+        """Test submitting approved review."""
+        self.queue.add_to_queue("test1", "Test content", "OWASP/ASVS")
+
+        success, error = self.queue.submit_review("test1", "approved")
+
+        self.assertTrue(success)
+        self.assertIsNone(error)
+        self.assertEqual(self.queue.stats["approved"], 1)
+        self.assertEqual(self.queue.stats["pending"], 0)
+
+    def test_submit_review_rejected(self):
+        """Test submitting rejected review."""
+        self.queue.add_to_queue("test1", "Noise content", "OWASP/ASVS")
+
+        success, error = self.queue.submit_review("test1", "rejected")
+
+        self.assertTrue(success)
+        self.assertIsNone(error)
+        self.assertEqual(self.queue.stats["rejected"], 1)
+        self.assertEqual(self.queue.stats["pending"], 0)
+        self.assertEqual(self.queue.stats["total_reviewed"], 1)
+
+    def test_submit_review_invalid_decision(self):
+        """Test submitting with invalid decision."""
+        self.queue.add_to_queue("test1", "Content", "OWASP/ASVS")
+
+        success, error = self.queue.submit_review("test1", "invalid")
+
+        self.assertFalse(success)
+        self.assertIsNotNone(error)
+        self.assertIn("Invalid decision", error)
+
+    def test_submit_review_not_found(self):
+        """Test submitting review for nonexistent content."""
+        success, error = self.queue.submit_review("nonexistent", "approved")
+
+        self.assertFalse(success)
+        self.assertIsNotNone(error)
+        self.assertIn("not found", error)
+
+    def test_submit_review_already_reviewed(self):
+        """Test submitting review for already reviewed content."""
+        self.queue.add_to_queue("test1", "Content", "OWASP/ASVS")
+        self.queue.submit_review("test1", "approved")
+
+        # Try to review again
+        success, error = self.queue.submit_review("test1", "rejected")
+
+        self.assertFalse(success)
+        self.assertIsNotNone(error)
+
+    def test_review_logging(self):
+        """Test that reviews are logged to JSONL."""
+        self.queue.add_to_queue("test1", "Content to review", "OWASP/ASVS")
+        self.queue.submit_review("test1", "approved", "Good content")
+
+        # Check log file exists
+        log_files = list(Path(self.temp_dir).glob("reviews_*.jsonl"))
+        self.assertEqual(len(log_files), 1)
+
+        # Verify log content
+        with open(log_files[0], "r") as f:
+            log_line = f.readline()
+            log_data = json.loads(log_line)
+            self.assertEqual(log_data["id"], "test1")
+            self.assertEqual(log_data["decision"], "approved")
+            self.assertEqual(log_data["notes"], "Good content")
+
+    def test_get_pending_items(self):
+        """Test retrieving pending items."""
+        self.queue.add_to_queue("test1", "Content 1", "OWASP/ASVS")
+        self.queue.add_to_queue("test2", "Content 2", "OWASP/wstg")
+        self.queue.submit_review("test1", "approved")
+
+        pending = self.queue.get_pending_items()
+
+        self.assertEqual(len(pending), 1)
+        self.assertEqual(pending[0]["id"], "test2")
+
+    def test_get_pending_items_limit(self):
+        """Test limit parameter for pending items."""
+        for i in range(15):
+            self.queue.add_to_queue(f"test{i}", f"Content {i}", "OWASP/ASVS")
+
+        pending = self.queue.get_pending_items(limit=5)
+
+        self.assertEqual(len(pending), 5)
+
+    def test_get_queue_stats(self):
+        """Test getting queue statistics."""
+        self.queue.add_to_queue("test1", "Content 1", "OWASP/ASVS")
+        self.queue.add_to_queue("test2", "Content 2", "OWASP/wstg")
+        self.queue.submit_review("test1", "approved")
+
+        stats = self.queue.get_queue_stats()
+
+        self.assertEqual(stats["pending"], 1)
+        self.assertEqual(stats["approved"], 1)
+        self.assertEqual(stats["rejected"], 0)
+        self.assertEqual(stats["total_reviewed"], 1)
+
+    def test_get_review_history(self):
+        """Test retrieving review history."""
+        self.queue.add_to_queue("test1", "Content 1", "OWASP/ASVS")
+        self.queue.add_to_queue("test2", "Content 2", "OWASP/wstg")
+        self.queue.submit_review("test1", "approved")
+        self.queue.submit_review("test2", "rejected")
+
+        history = self.queue.get_review_history()
+
+        self.assertEqual(len(history), 2)
+        self.assertEqual(history[0]["id"], "test2")  # Most recent first
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/application/utils/review_queue.py b/application/utils/review_queue.py
new file mode 100644
index 000000000..fef827604
--- /dev/null
+++ b/application/utils/review_queue.py
@@ -0,0 +1,204 @@
+"""
+GSoC Module D: Human-in-the-Loop (HITL) Review Backend
+
+Provides REST API endpoints for content review with JSONL logging.
+Designed for fast keyboard-optimized review workflow (<3 seconds per item).
+
+Features:
+- Review queue management
+- JSONL-based logging (S3/MinIO ready)
+- User authentication placeholder
+- Statistics dashboard data
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class ReviewQueue:
+    """Manages content review queue and logging."""
+
+    PENDING = "pending"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+
+    def __init__(self, log_dir: str = "review_logs"):
+        """
+        Initialize review queue.
+
+        Args:
+            log_dir: Directory to store JSONL logs
+        """
+        self.log_dir = Path(log_dir)
+        self.log_dir.mkdir(exist_ok=True)
+        self.queue: List[Dict] = []
+        self.stats = {
+            "total_reviewed": 0,
+            "approved": 0,
+            "rejected": 0,
+            "pending": 0,
+        }
+
+    def add_to_queue(self, content_id: str, content: str, source: str) -> bool:
+        """
+        Add content to review queue.
+
+        Args:
+            content_id: Unique identifier for the content
+            content: The content to review
+            source: Source of the content (repo name, URL, etc.)
+
+        Returns:
+            True if added successfully
+        """
+        try:
+            item = {
+                "id": content_id,
+                "content": content,
+                "source": source,
+                "status": self.PENDING,
+                "created_at": datetime.utcnow().isoformat(),
+                "reviewed_at": None,
+                "decision": None,
+            }
+            self.queue.append(item)
+            self.stats["pending"] += 1
+            logger.info(f"Added content {content_id} to review queue")
+            return True
+        except Exception as e:
+            logger.error(f"Error adding to queue: {e}")
+            return False
+
+    def submit_review(
+        self, content_id: str, decision: str, notes: str = ""
+    ) -> Tuple[bool, Optional[str]]:
+        """
+        Submit review decision for content.
+
+        Args:
+            content_id: ID of content being reviewed
+            decision: "approved" or "rejected"
+            notes: Optional reviewer notes
+
+        Returns:
+            Tuple of (success, error_message)
+        """
+        if decision not in [self.APPROVED, self.REJECTED]:
+            return False, "Invalid decision (must be 'approved' or 'rejected')"
+
+        try:
+            # Find content in queue
+            content_item = None
+            for item in self.queue:
+                if item["id"] == content_id:
+                    content_item = item
+                    break
+
+            if not content_item:
+                return False, f"Content {content_id} not found"
+
+            if content_item["status"] != self.PENDING:
+                return False, f"Content already reviewed: {content_item['status']}"
+
+            # Update status
+            content_item["status"] = decision
+            content_item["decision"] = decision
+            content_item["reviewed_at"] = datetime.utcnow().isoformat()
+            content_item["notes"] = notes
+
+            # Log to JSONL
+            self._log_review(content_item)
+
+            # Update stats
+            self.stats["pending"] -= 1
+            if decision == self.APPROVED:
+                self.stats["approved"] += 1
+            else:
+                self.stats["rejected"] += 1
+            self.stats["total_reviewed"] += 1
+
+            logger.info(
+                f"Review submitted for {content_id}: {decision}"
+            )
+            return True, None
+
+        except Exception as e:
+            logger.error(f"Error submitting review: {e}")
+            return False, str(e)
+
+    def _log_review(self, item: Dict) -> bool:
+        """
+        Log review decision to JSONL file.
+
+        Args:
+            item: Review item with decision
+
+        Returns:
+            True if logged successfully
+        """
+        try:
+            log_file = (
+                self.log_dir /
+                f"reviews_{datetime.utcnow().strftime('%Y%m%d')}.jsonl"
+            )
+
+            with open(log_file, "a") as f:
+                f.write(json.dumps(item) + "\n")
+
+            logger.debug(f"Review logged to {log_file}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error logging review: {e}")
+            return False
+
+    def get_queue_stats(self) -> Dict:
+        """Get review queue statistics."""
+        return self.stats.copy()
+
+    def get_pending_items(self, limit: int = 10) -> List[Dict]:
+        """
+        Get pending items from queue.
+
+        Args:
+            limit: Maximum number of items to return
+
+        Returns:
+            List of pending review items
+        """
+        pending = [
+            {
+                "id": item["id"],
+                "content": item["content"],
+                "source": item["source"],
+                "created_at": item["created_at"],
+            }
+            for item in self.queue
+            if item["status"] == self.PENDING
+        ]
+        return pending[:limit]
+
+    def get_review_history(self, limit: int = 100) -> List[Dict]:
+        """Get review history from JSONL logs."""
+        history = []
+        try:
+            for log_file in self.log_dir.glob("reviews_*.jsonl"):
+                with open(log_file, "r") as f:
+                    for line in f:
+                        try:
+                            history.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            logger.warning(f"Invalid JSON in {log_file}")
+        except Exception as e:
+            logger.error(f"Error reading review history: {e}")
+
+        return sorted(
+            history,
+            key=lambda x: x.get("reviewed_at", x.get("created_at", "")),
+            reverse=True,
+        )[:limit]
diff --git a/application/web/review_api.py b/application/web/review_api.py
new file mode 100644
index 000000000..3c498582f
--- /dev/null
+++ b/application/web/review_api.py
@@ -0,0 +1,118 @@
+"""
+GSoC Module D: HITL Review API Endpoints
+
+REST API for human-in-the-loop review interface.
+Optimized for keyboard shortcuts and fast review workflow.
+"""
+
+from flask import Blueprint, request, jsonify
+from application.utils.review_queue import ReviewQueue
+
+review_bp = Blueprint("review", __name__, url_prefix="/api/review")
+review_queue = ReviewQueue()
+
+
+@review_bp.route("/queue/pending", methods=["GET"])
+def get_pending_queue():
+    """
+    Get pending content from review queue.
+
+    Query params:
+        limit: Maximum number of items (default: 10)
+
+    Returns:
+        JSON list of pending items
+    """
+    try:
+        limit = request.args.get("limit", default=10, type=int)
+        pending = review_queue.get_pending_items(limit)
+        return jsonify({"success": True, "items": pending}), 200
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)}), 500
+
+
+@review_bp.route("/submit", methods=["POST"])
+def submit_review():
+    """
+    Submit a review decision.
+
+    JSON Body:
+        {
+            "content_id": "abc123",
+            "decision": "approved|rejected",
+            "notes": "optional notes"
+        }
+
+    Returns:
+        JSON {"success": true/false, "message": "..."}
+    """
+    try:
+        data = request.get_json()
+
+        content_id = data.get("content_id")
+        decision = data.get("decision")
+        notes = data.get("notes", "")
+
+        if not content_id or not decision:
+            return (
+                jsonify({
+                    "success": False,
+                    "error": "Missing content_id or decision"
+                }),
+                400,
+            )
+
+        success, error = review_queue.submit_review(
+            content_id, decision, notes
+        )
+
+        if success:
+            return (
+                jsonify({
+                    "success": True,
+                    "message": f"Content {decision}: {content_id}"
+                }),
+                200,
+            )
+        else:
+            return (
+                jsonify({"success": False, "error": error}),
+                400,
+            )
+
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)}), 500
+
+
+@review_bp.route("/stats", methods=["GET"])
+def get_stats():
+    """
+    Get review queue statistics.
+
+    Returns:
+        JSON with stats: {total_reviewed, approved, rejected, pending}
+    """
+    try:
+        stats = review_queue.get_queue_stats()
+        return jsonify({"success": True, "stats": stats}), 200
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)}), 500
+
+
+@review_bp.route("/history", methods=["GET"])
+def get_history():
+    """
+    Get review history from JSONL logs.
+
+    Query params:
+        limit: Maximum number of records (default: 100)
+
+    Returns:
+        JSON list of reviewed items
+    """
+    try:
+        limit = request.args.get("limit", default=100, type=int)
+        history = review_queue.get_review_history(limit)
+        return jsonify({"success": True, "history": history}), 200
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)}), 500
diff --git a/review_interface.html b/review_interface.html
new file mode 100644
index 000000000..3ad7c8cfc
--- /dev/null
+++ b/review_interface.html
@@ -0,0 +1,364 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OpenCRE Review Interface - Module D</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #f5f5f5;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+            padding: 30px;
+        }
+        
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 30px;
+            border-bottom: 2px solid #f0f0f0;
+            padding-bottom: 20px;
+        }
+        
+        h1 { color: #333; font-size: 24px; }
+        
+        .stats {
+            display: flex;
+            gap: 20px;
+            font-size: 14px;
+        }
+        
+        .stat {
+            text-align: center;
+        }
+        
+        .stat-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #0066cc;
+        }
+        
+        .stat-label {
+            color: #666;
+            margin-top: 4px;
+        }
+        
+        .review-item {
+            background: #f9f9f9;
+            border: 1px solid #eee;
+            border-radius: 6px;
+            padding: 20px;
+            margin-bottom: 20px;
+        }
+        
+        .item-header {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 15px;
+        }
+        
+        .item-id {
+            font-weight: bold;
+            color: #333;
+            font-family: monospace;
+        }
+        
+        .item-source {
+            color: #0066cc;
+            font-size: 12px;
+        }
+        
+        .item-content {
+            background: white;
+            border: 1px solid #ddd;
+            padding: 15px;
+            border-radius: 4px;
+            line-height: 1.6;
+            color: #444;
+            margin-bottom: 15px;
+            max-height: 200px;
+            overflow-y: auto;
+            font-size: 14px;
+        }
+        
+        .actions {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 15px;
+        }
+        
+        button {
+            flex: 1;
+            padding: 12px 16px;
+            border: none;
+            border-radius: 4px;
+            font-size: 14px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .btn-approve {
+            background: #28a745;
+            color: white;
+        }
+        
+        .btn-approve:hover { background: #218838; }
+        .btn-approve:active { transform: scale(0.98); }
+        
+        .btn-reject {
+            background: #dc3545;
+            color: white;
+        }
+        
+        .btn-reject:hover { background: #c82333; }
+        .btn-reject:active { transform: scale(0.98); }
+        
+        .notes {
+            width: 100%;
+            padding: 8px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 12px;
+            font-family: monospace;
+            resize: vertical;
+            min-height: 40px;
+        }
+        
+        .keyboard-hints {
+            background: #e8f4f8;
+            border-left: 4px solid #0066cc;
+            padding: 12px;
+            margin-top: 20px;
+            border-radius: 4px;
+            font-size: 12px;
+            color: #333;
+        }
+        
+        .empty-state {
+            text-align: center;
+            padding: 40px;
+            color: #999;
+        }
+        
+        .timer {
+            font-size: 12px;
+            color: #666;
+            margin-top: 10px;
+        }
+        
+        .loading { opacity: 0.6; pointer-events: none; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🔍 OpenCRE Content Review</h1>
+            <div class="stats">
+                <div class="stat">
+                    <div class="stat-value" id="approvedCount">0</div>
+                    <div class="stat-label">Approved</div>
+                </div>
+                <div class="stat">
+                    <div class="stat-value" id="rejectedCount">0</div>
+                    <div class="stat-label">Rejected</div>
+                </div>
+                <div class="stat">
+                    <div class="stat-value" id="pendingCount">1</div>
+                    <div class="stat-label">Pending</div>
+                </div>
+            </div>
+        </div>
+        
+        <div id="reviewContainer">
+            <!-- Review items populated by JavaScript -->
+        </div>
+        
+        <div class="empty-state" id="emptyState" style="display: none;">
+            ✓ All items reviewed! Great work.
+        </div>
+        
+        <div class="keyboard-hints">
+            <strong>⌨️ Keyboard Shortcuts:</strong><br>
+            <code>Y</code> to approve • <code>N</code> to reject • <code>↓</code> next item
+        </div>
+    </div>
+
+    <script>
+        class ReviewInterface {
+            constructor() {
+                this.currentItem = null;
+                this.startTime = null;
+                this.approved = 0;
+                this.rejected = 0;
+                
+                // Demo data (replace with API calls)
+                this.queue = [
+                    {
+                        id: "commit_abc123",
+                        content: "Fix: Add input validation for CSV import - check file extension and size",
+                        source: "OWASP/OpenCRE"
+                    },
+                    {
+                        id: "commit_def456",
+                        content: "Feature: Implement gap analysis caching for improved performance",
+                        source: "OWASP/OpenCRE"
+                    },
+                    {
+                        id: "commit_ghi789",
+                        content: "Docs: Update README with API documentation",
+                        source: "OWASP/OpenCRE"
+                    }
+                ];
+                
+                this.init();
+            }
+            
+            init() {
+                this.setupKeyboardShortcuts();
+                this.loadNextItem();
+                this.updateStats();
+            }
+            
+            setupKeyboardShortcuts() {
+                document.addEventListener('keydown', (e) => {
+                    if (e.key.toLowerCase() === 'y') {
+                        e.preventDefault();
+                        this.approve();
+                    } else if (e.key.toLowerCase() === 'n') {
+                        e.preventDefault();
+                        this.reject();
+                    } else if (e.key === 'ArrowDown') {
+                        e.preventDefault();
+                        this.loadNextItem();
+                    }
+                });
+            }
+            
+            loadNextItem() {
+                if (this.queue.length === 0) {
+                    document.getElementById('reviewContainer').innerHTML = '';
+                    document.getElementById('emptyState').style.display = 'block';
+                    return;
+                }
+                
+                this.currentItem = this.queue.shift();
+                this.startTime = Date.now();
+                this.renderItem();
+            }
+            
+            renderItem() {
+                const item = this.currentItem;
+                const html = `
+                    <div class="review-item">
+                        <div class="item-header">
+                            <div class="item-id">#${item.id}</div>
+                            <div class="item-source">${item.source}</div>
+                        </div>
+                        <div class="item-content">${this.escapeHtml(item.content)}</div>
+                        <div class="actions">
+                            <button class="btn-approve" onclick="reviewUI.approve()">
+                                ✓ Approve (Y)
+                            </button>
+                            <button class="btn-reject" onclick="reviewUI.reject()">
+                                ✗ Reject (N)
+                            </button>
+                        </div>
+                        <textarea class="notes" placeholder="Optional notes..." id="notesField"></textarea>
+                        <div class="timer" id="timer">Reviewing...</div>
+                    </div>
+                `;
+                
+                document.getElementById('reviewContainer').innerHTML = html;
+                document.getElementById('notesField').focus();
+                this.startTimer();
+            }
+            
+            startTimer() {
+                const timerEl = document.getElementById('timer');
+                const interval = setInterval(() => {
+                    const elapsed = Math.round((Date.now() - this.startTime) / 1000);
+                    timerEl.textContent = `Time: ${elapsed}s`;
+                    if (elapsed > 180) clearInterval(interval); // Stop at 3 minutes
+                }, 100);
+            }
+            
+            approve() {
+                const item = this.currentItem;
+                const notes = document.getElementById('notesField')?.value || '';
+                
+                console.log('Approved:', {
+                    ...item,
+                    notes,
+                    decision: 'approved',
+                    timeSpent: Math.round((Date.now() - this.startTime) / 1000)
+                });
+                
+                this.approved++;
+                this.logReview('approved');
+                this.loadNextItem();
+                this.updateStats();
+            }
+            
+            reject() {
+                const item = this.currentItem;
+                const notes = document.getElementById('notesField')?.value || '';
+                
+                console.log('Rejected:', {
+                    ...item,
+                    notes,
+                    decision: 'rejected',
+                    timeSpent: Math.round((Date.now() - this.startTime) / 1000)
+                });
+                
+                this.rejected++;
+                this.logReview('rejected');
+                this.loadNextItem();
+                this.updateStats();
+            }
+            
+            logReview(decision) {
+                // TODO: Replace with API call to /api/review/submit
+                // fetch('/api/review/submit', {
+                //     method: 'POST',
+                //     headers: {'Content-Type': 'application/json'},
+                //     body: JSON.stringify({
+                //         content_id: this.currentItem.id,
+                //         decision: decision,
+                //         notes: document.getElementById('notesField').value
+                //     })
+                // });
+            }
+            
+            updateStats() {
+                document.getElementById('approvedCount').textContent = this.approved;
+                document.getElementById('rejectedCount').textContent = this.rejected;
+                document.getElementById('pendingCount').textContent = this.queue.length;
+            }
+            
+            escapeHtml(text) {
+                const div = document.createElement('div');
+                div.textContent = text;
+                return div.innerHTML;
+            }
+        }
+        
+        // Initialize on load
+        let reviewUI;
+        document.addEventListener('DOMContentLoaded', () => {
+            reviewUI = new ReviewInterface();
+        });
+    </script>
+</body>
+</html>