diff --git a/.gitignore b/.gitignore
index e227ca3..4a9bccf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,7 +9,8 @@
 .LSOverride
 
 # Icon must end with two \r
-Icon
+Icon
+
 
 # Thumbnails
 ._*
@@ -57,3 +58,5 @@ Temporary Items
 
 # Custom rules (everything added below won't be overriden by 'Generate .gitignore File' if you use 'Update' option)
 
+config.config
+variables.env
\ No newline at end of file
diff --git a/config.conf b/config.conf.example
similarity index 100%
rename from config.conf
rename to config.conf.example
diff --git a/ui_template_gaps.py b/ui_template_gaps.py
index fc27a34..d3ec1dd 100644
--- a/ui_template_gaps.py
+++ b/ui_template_gaps.py
@@ -1,18 +1,23 @@
 #!/usr/bin/env python3
-"""
-ui_template_gaps.py - Data Gap Monitoring Interface
-Provides visual interface for tracking and filling data gaps
+
 """
 
+ui_template_gaps.py - Data Gap Monitoring Interface
+
+Provides visual interface for tracking and filling data gaps and monitoring technical indicator coverage
+
+"""
+
+
 def get_gaps_monitoring_html():
-    """Return the gaps monitoring page HTML"""
+    """Return the gaps monitoring page HTML with indicator coverage section"""
     return """
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Gap Monitoring - Trading System</title>
+    <title>Gap Monitoring & Indicator Coverage - Crypto Data Collector</title>
     <style>
         * {
             margin: 0;
@@ -21,7 +26,7 @@ def get_gaps_monitoring_html():
         }
         
         body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             min-height: 100vh;
             padding: 20px;
@@ -30,129 +35,133 @@ def get_gaps_monitoring_html():
         .container {
             max-width: 1400px;
             margin: 0 auto;
-            background: white;
-            border-radius: 10px;
-            box-shadow: 0 10px 40px rgba(0,0,0,0.1);
-            overflow: hidden;
         }
         
         .header {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
+            background: white;
             padding: 30px;
-            text-align: center;
+            border-radius: 15px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+            margin-bottom: 30px;
         }
         
         .header h1 {
+            color: #333;
             font-size: 32px;
             margin-bottom: 10px;
         }
         
         .header p {
-            opacity: 0.9;
+            color: #666;
             font-size: 16px;
         }
         
-        .nav-bar {
-            background: #2d3748;
-            padding: 15px 30px;
+        .nav-tabs {
             display: flex;
             gap: 10px;
-            flex-wrap: wrap;
+            margin-bottom: 20px;
+            background: white;
+            padding: 15px;
+            border-radius: 15px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
         }
         
-        .nav-button {
-            background: #4a5568;
-            color: white;
+        .nav-tab {
+            padding: 12px 24px;
+            background: #f0f0f0;
             border: none;
-            padding: 10px 20px;
-            border-radius: 5px;
+            border-radius: 8px;
             cursor: pointer;
-            font-size: 14px;
+            font-size: 16px;
+            font-weight: 500;
             transition: all 0.3s;
         }
         
-        .nav-button:hover {
-            background: #667eea;
-            transform: translateY(-2px);
+        .nav-tab:hover {
+            background: #e0e0e0;
         }
         
-        .nav-button.active {
-            background: #667eea;
+        .nav-tab.active {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+        
+        .tab-content {
+            display: none;
+        }
+        
+        .tab-content.active {
+            display: block;
+        }
+        
+        .card {
+            background: white;
+            padding: 30px;
+            border-radius: 15px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+            margin-bottom: 30px;
+        }
+        
+        .card h2 {
+            color: #333;
+            font-size: 24px;
+            margin-bottom: 20px;
+            padding-bottom: 15px;
+            border-bottom: 2px solid #667eea;
         }
         
         .stats-grid {
             display: grid;
             grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
             gap: 20px;
-            padding: 30px;
-            background: #f7fafc;
-        }
-        
-        .stat-card {
-            background: white;
-            padding: 20px;
-            border-radius: 8px;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-            text-align: center;
-        }
-        
-        .stat-value {
-            font-size: 32px;
-            font-weight: bold;
-            color: #667eea;
-            margin: 10px 0;
-        }
-        
-        .stat-label {
-            color: #718096;
-            font-size: 14px;
-        }
-        
-        .content {
-            padding: 30px;
-        }
-        
-        .section {
             margin-bottom: 30px;
         }
         
-        .section-title {
-            font-size: 20px;
-            font-weight: bold;
-            color: #2d3748;
-            margin-bottom: 15px;
-            padding-bottom: 10px;
-            border-bottom: 2px solid #e2e8f0;
+        .stat-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
         }
         
-        .pairs-table {
+        .stat-card h3 {
+            font-size: 14px;
+            opacity: 0.9;
+            margin-bottom: 10px;
+        }
+        
+        .stat-card .value {
+            font-size: 32px;
+            font-weight: bold;
+        }
+        
+        .table-container {
+            overflow-x: auto;
+            margin-top: 20px;
+        }
+        
+        table {
             width: 100%;
             border-collapse: collapse;
-            background: white;
-            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-            border-radius: 8px;
-            overflow: hidden;
         }
         
-        .pairs-table thead {
-            background: #2d3748;
-            color: white;
-        }
-        
-        .pairs-table th {
-            padding: 15px;
+        th, td {
+            padding: 12px;
             text-align: left;
+            border-bottom: 1px solid #e0e0e0;
+        }
+        
+        th {
+            background: #f8f9fa;
             font-weight: 600;
+            color: #333;
+            position: sticky;
+            top: 0;
         }
         
-        .pairs-table td {
-            padding: 12px 15px;
-            border-bottom: 1px solid #e2e8f0;
-        }
-        
-        .pairs-table tbody tr:hover {
-            background: #f7fafc;
+        tr:hover {
+            background: #f8f9fa;
         }
         
         .status-badge {
@@ -164,58 +173,116 @@ def get_gaps_monitoring_html():
         }
         
         .status-excellent {
-            background: #c6f6d5;
-            color: #22543d;
+            background: #d4edda;
+            color: #155724;
         }
         
         .status-good {
-            background: #bee3f8;
-            color: #2c5282;
+            background: #d1ecf1;
+            color: #0c5460;
         }
         
-        .status-partial {
-            background: #feebc8;
-            color: #744210;
+        .status-warning {
+            background: #fff3cd;
+            color: #856404;
         }
         
-        .status-poor {
-            background: #fed7d7;
-            color: #742a2a;
+        .status-critical {
+            background: #f8d7da;
+            color: #721c24;
         }
         
-        .action-button {
-            background: #667eea;
+        .progress-bar {
+            width: 100%;
+            height: 24px;
+            background: #e0e0e0;
+            border-radius: 12px;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            transition: width 0.3s;
+            display: flex;
+            align-items: center;
+            justify-content: center;
             color: white;
-            border: none;
-            padding: 6px 12px;
-            border-radius: 4px;
-            cursor: pointer;
             font-size: 12px;
-            margin-right: 5px;
+            font-weight: bold;
+        }
+        
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
             transition: all 0.3s;
+            margin: 2px;
         }
         
-        .action-button:hover {
-            background: #5a67d8;
-            transform: translateY(-1px);
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
         }
         
-        .action-button.secondary {
-            background: #48bb78;
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
         }
         
-        .action-button.secondary:hover {
-            background: #38a169;
+        .btn-success {
+            background: #28a745;
+            color: white;
+        }
+        
+        .btn-success:hover {
+            background: #218838;
+        }
+        
+        .btn-warning {
+            background: #ffc107;
+            color: #333;
+        }
+        
+        .btn-warning:hover {
+            background: #e0a800;
+        }
+        
+        .btn-danger {
+            background: #dc3545;
+            color: white;
+        }
+        
+        .btn-danger:hover {
+            background: #c82333;
+        }
+        
+        .btn-secondary {
+            background: #6c757d;
+            color: white;
+        }
+        
+        .btn-secondary:hover {
+            background: #5a6268;
+        }
+        
+        .btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
         }
         
         .loading {
             text-align: center;
             padding: 40px;
-            color: #718096;
+            color: #666;
         }
         
-        .spinner {
-            border: 4px solid #e2e8f0;
+        .loading-spinner {
+            border: 4px solid #f3f3f3;
             border-top: 4px solid #667eea;
             border-radius: 50%;
             width: 40px;
@@ -229,552 +296,573 @@ def get_gaps_monitoring_html():
             100% { transform: rotate(360deg); }
         }
         
-        .modal {
-            display: none;
-            position: fixed;
-            z-index: 1000;
-            left: 0;
-            top: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0,0,0,0.5);
-        }
-        
-        .modal-content {
-            background: white;
-            margin: 5% auto;
-            padding: 30px;
-            border-radius: 10px;
-            max-width: 800px;
-            max-height: 80vh;
-            overflow-y: auto;
-            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
-        }
-        
-        .modal-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 20px;
-            padding-bottom: 15px;
-            border-bottom: 2px solid #e2e8f0;
-        }
-        
-        .modal-title {
-            font-size: 24px;
-            font-weight: bold;
-            color: #2d3748;
-        }
-        
-        .close {
-            font-size: 28px;
-            font-weight: bold;
-            color: #718096;
-            cursor: pointer;
-            transition: color 0.3s;
-        }
-        
-        .close:hover {
-            color: #2d3748;
-        }
-        
-        .gap-details {
-            margin-top: 20px;
-        }
-        
-        .gap-item {
-            background: #f7fafc;
+        .alert {
             padding: 15px;
             border-radius: 8px;
-            margin-bottom: 10px;
-            border-left: 4px solid #667eea;
+            margin-bottom: 20px;
         }
         
-        .gap-info {
-            display: grid;
-            grid-template-columns: repeat(2, 1fr);
-            gap: 10px;
-            margin-top: 10px;
+        .alert-info {
+            background: #d1ecf1;
+            color: #0c5460;
+            border: 1px solid #bee5eb;
         }
         
-        .gap-info-item {
+        .alert-success {
+            background: #d4edda;
+            color: #155724;
+            border: 1px solid #c3e6cb;
+        }
+        
+        .alert-warning {
+            background: #fff3cd;
+            color: #856404;
+            border: 1px solid #ffeeba;
+        }
+        
+        .alert-danger {
+            background: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+        }
+        
+        .filter-bar {
             display: flex;
-            justify-content: space-between;
+            gap: 15px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
         }
         
-        .gap-label {
-            color: #718096;
-            font-weight: 600;
+        .filter-bar input,
+        .filter-bar select {
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 14px;
         }
         
-        .gap-value {
-            color: #2d3748;
+        .filter-bar input {
+            flex: 1;
+            min-width: 200px;
         }
         
-        .progress-bar {
-            width: 100%;
-            height: 8px;
-            background: #e2e8f0;
-            border-radius: 4px;
-            overflow: hidden;
-            margin: 5px 0;
+        .indicator-details {
+            font-size: 12px;
+            color: #666;
+            margin-top: 5px;
         }
         
-        .progress-fill {
-            height: 100%;
-            background: linear-gradient(90deg, #667eea, #48bb78);
-            transition: width 0.3s;
+        .missing-list {
+            max-height: 200px;
+            overflow-y: auto;
+            font-size: 12px;
+            color: #666;
+            margin-top: 5px;
+            padding: 10px;
+            background: #f8f9fa;
+            border-radius: 6px;
         }
         
-        .interval-badge {
+        .back-link {
             display: inline-block;
-            padding: 2px 8px;
-            background: #edf2f7;
-            border-radius: 4px;
-            font-size: 11px;
-            font-weight: 600;
-            color: #2d3748;
-            margin-right: 5px;
+            color: #667eea;
+            text-decoration: none;
+            margin-bottom: 20px;
+            font-weight: 500;
+        }
+        
+        .back-link:hover {
+            text-decoration: underline;
         }
     </style>
 </head>
 <body>
     <div class="container">
         <div class="header">
-            <h1>📊 Data Gap Monitoring</h1>
-            <p>Track and fill data gaps across all trading pairs</p>
+            <a href="/" class="back-link">← Back to Dashboard</a>
+            <h1>📊 Data Quality Monitor</h1>
+            <p>Track and resolve data gaps and ensure 100% technical indicator coverage</p>
         </div>
         
-        <div class="nav-bar">
-            <button onclick="window.location.href='/'" class="nav-button">Dashboard</button>
-            <button onclick="window.location.href='/config'" class="nav-button">Config</button>
-            <button onclick="window.location.href='/gaps'" class="nav-button active">Gaps</button>
+        <div class="nav-tabs">
+            <button class="nav-tab active" onclick="switchTab('gaps')">Gap Detection</button>
+            <button class="nav-tab" onclick="switchTab('indicators')">Indicator Coverage</button>
         </div>
         
-        <div class="stats-grid">
-            <div class="stat-card">
-                <div class="stat-label">Total Pairs</div>
-                <div class="stat-value" id="totalPairs">-</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Pairs with Gaps</div>
-                <div class="stat-value" id="pairsWithGaps">-</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Total Missing Records</div>
-                <div class="stat-value" id="totalMissing">-</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-label">Avg Coverage</div>
-                <div class="stat-value" id="avgCoverage">-</div>
-            </div>
-        </div>
-        
-        <div class="content">
-            <div class="section">
-                <div class="section-title">Trading Pairs Gap Status</div>
-                <div id="loadingIndicator" class="loading">
-                    <div class="spinner"></div>
+        <!-- GAPS TAB -->
+        <div id="gaps-tab" class="tab-content active">
+            <div class="card">
+                <h2>Trading Pairs Gap Status</h2>
+                <div id="gaps-loading" class="loading">
+                    <div class="loading-spinner"></div>
                     <p>Loading gap data...</p>
                 </div>
-                <table class="pairs-table" id="pairsTable" style="display:none;">
-                    <thead>
-                        <tr>
-                            <th>Symbol</th>
-                            <th>From Date</th>
-                            <th>To Date</th>
-                            <th>Intervals</th>
-                            <th>Coverage</th>
-                            <th>Status</th>
-                            <th>Actions</th>
-                        </tr>
-                    </thead>
-                    <tbody id="pairsTableBody">
-                    </tbody>
-                </table>
+                <div id="gaps-content" style="display: none;">
+                    <div class="filter-bar">
+                        <input type="text" id="gap-search" placeholder="Search symbol or interval...">
+                        <select id="gap-filter">
+                            <option value="all">All Pairs</option>
+                            <option value="has-gaps">With Gaps Only</option>
+                            <option value="complete">Complete Only</option>
+                        </select>
+                        <button class="btn btn-primary" onclick="loadGapsData()">🔄 Refresh</button>
+                        <button class="btn btn-success" onclick="fillAllGaps()">Fill All Gaps</button>
+                    </div>
+                    
+                    <div class="table-container">
+                        <table id="gaps-table">
+                            <thead>
+                                <tr>
+                                    <th>Symbol</th>
+                                    <th>Interval</th>
+                                    <th>Coverage</th>
+                                    <th>Total Records</th>
+                                    <th>Missing Records</th>
+                                    <th>Gaps Count</th>
+                                    <th>Status</th>
+                                    <th>Actions</th>
+                                </tr>
+                            </thead>
+                            <tbody id="gaps-tbody">
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
             </div>
         </div>
-    </div>
-    
-    <!-- Gap Details Modal -->
-    <div id="gapModal" class="modal">
-        <div class="modal-content">
-            <div class="modal-header">
-                <div class="modal-title" id="modalTitle">Gap Details</div>
-                <span class="close" onclick="closeModal()">&times;</span>
+        
+        <!-- INDICATORS TAB -->
+        <div id="indicators-tab" class="tab-content">
+            <div class="card">
+                <h2>Technical Indicator Coverage Summary</h2>
+                <div id="indicator-summary-loading" class="loading">
+                    <div class="loading-spinner"></div>
+                    <p>Loading indicator coverage summary...</p>
+                </div>
+                <div id="indicator-summary-content" style="display: none;">
+                    <div class="stats-grid">
+                        <div class="stat-card">
+                            <h3>Total Combinations</h3>
+                            <div class="value" id="total-combinations">0</div>
+                        </div>
+                        <div class="stat-card">
+                            <h3>Complete (≥99.9%)</h3>
+                            <div class="value" id="complete-combinations">0</div>
+                        </div>
+                        <div class="stat-card">
+                            <h3>Incomplete</h3>
+                            <div class="value" id="incomplete-combinations">0</div>
+                        </div>
+                        <div class="stat-card">
+                            <h3>Average Coverage</h3>
+                            <div class="value" id="avg-coverage">0%</div>
+                        </div>
+                    </div>
+                </div>
             </div>
-            <div id="modalBody">
-                <div class="loading">
-                    <div class="spinner"></div>
-                    <p>Loading details...</p>
+            
+            <div class="card">
+                <h2>Indicator Coverage by Symbol/Interval</h2>
+                <div id="indicators-loading" class="loading">
+                    <div class="loading-spinner"></div>
+                    <p>Loading indicator coverage data...</p>
+                </div>
+                <div id="indicators-content" style="display: none;">
+                    <div class="filter-bar">
+                        <input type="text" id="indicator-search" placeholder="Search symbol or interval...">
+                        <select id="indicator-filter">
+                            <option value="all">All Pairs</option>
+                            <option value="incomplete">Incomplete Only (<100%)</option>
+                            <option value="complete">Complete Only (≥99.9%)</option>
+                        </select>
+                        <button class="btn btn-primary" onclick="loadIndicatorData()">🔄 Refresh</button>
+                        <button class="btn btn-success" onclick="backfillAllIndicators()">Backfill All Incomplete</button>
+                    </div>
+                    
+                    <div class="table-container">
+                        <table id="indicators-table">
+                            <thead>
+                                <tr>
+                                    <th>Symbol</th>
+                                    <th>Interval</th>
+                                    <th>Coverage</th>
+                                    <th>Total OHLCV</th>
+                                    <th>Complete Records</th>
+                                    <th>Incomplete Records</th>
+                                    <th>Missing Indicators</th>
+                                    <th>Actions</th>
+                                </tr>
+                            </thead>
+                            <tbody id="indicators-tbody">
+                            </tbody>
+                        </table>
+                    </div>
                 </div>
             </div>
         </div>
     </div>
     
-<script>
-    let gapData = [];
-    
-    async function loadGapData() {
-        try {
-            const response = await fetch('/api/gaps/all-pairs');
-            const result = await response.json();
-            
-            if (result.status === 'success' && result.data) {
-                gapData = result.data;
-                processAndDisplayData(gapData);
-            } else {
-                showError('Failed to load gap data: ' + (result.message || 'Unknown error'));
-            }
-        } catch (error) {
-            console.error('Error loading gap data:', error);
-            showError('Error loading gap data: ' + error.message);
-        }
-    }
-    
-    function processAndDisplayData(data) {
-        // Group by symbol
-        const symbolMap = new Map();
+    <script>
+        let gapsData = [];
+        let indicatorData = [];
         
-        data.forEach(item => {
-            if (!symbolMap.has(item.symbol)) {
-                symbolMap.set(item.symbol, {
-                    symbol: item.symbol,
-                    intervals: [],
-                    totalCoverage: 0,
-                    totalMissing: 0,
-                    totalRecords: 0,
-                    firstDate: item.first_record,
-                    lastDate: item.last_record,
-                    healthScore: null
-                });
-            }
+        // Tab switching
+        function switchTab(tab) {
+            // Update tab buttons
+            document.querySelectorAll('.nav-tab').forEach(btn => {
+                btn.classList.remove('active');
+            });
+            event.target.classList.add('active');
             
-            const symbolData = symbolMap.get(item.symbol);
-            symbolData.intervals.push({
-                interval: item.interval,
-                coverage: item.coverage_percent || 0,
-                missing: item.missing_records || 0,
-                total: item.total_records || 0,
-                gaps: item.gaps || []
+            // Update tab content
+            document.querySelectorAll('.tab-content').forEach(content => {
+                content.classList.remove('active');
+            });
+            document.getElementById(tab + '-tab').classList.add('active');
+            
+            // Load data if needed
+            if (tab === 'gaps' && gapsData.length === 0) {
+                loadGapsData();
+            } else if (tab === 'indicators' && indicatorData.length === 0) {
+                loadIndicatorData();
+                loadIndicatorSummary();
+            }
+        }
+        
+        // Load gaps data
+        async function loadGapsData() {
+            const loading = document.getElementById('gaps-loading');
+            const content = document.getElementById('gaps-content');
+            
+            loading.style.display = 'block';
+            content.style.display = 'none';
+            
+            try {
+                const response = await fetch('/api/gaps/all-pairs');
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    gapsData = data.data || [];
+                    renderGapsTable();
+                    content.style.display = 'block';
+                } else {
+                    alert('Error loading gaps data: ' + data.message);
+                }
+            } catch (error) {
+                console.error('Error loading gaps:', error);
+                alert('Failed to load gaps data');
+            } finally {
+                loading.style.display = 'none';
+            }
+        }
+        
+        // Render gaps table
+        function renderGapsTable() {
+            const tbody = document.getElementById('gaps-tbody');
+            const search = document.getElementById('gap-search').value.toLowerCase();
+            const filter = document.getElementById('gap-filter').value;
+            
+            let filtered = gapsData.filter(item => {
+                const matchSearch = item.symbol.toLowerCase().includes(search) || 
+                                  item.interval.toLowerCase().includes(search);
+                
+                let matchFilter = true;
+                if (filter === 'has-gaps') {
+                    matchFilter = item.gaps_count > 0;
+                } else if (filter === 'complete') {
+                    matchFilter = item.gaps_count === 0;
+                }
+                
+                return matchSearch && matchFilter;
             });
             
-            symbolData.totalMissing += item.missing_records || 0;
-            symbolData.totalRecords += item.total_records || 0;
-            
-            // Update date ranges
-            if (!symbolData.firstDate || (item.first_record && item.first_record < symbolData.firstDate)) {
-                symbolData.firstDate = item.first_record;
-            }
-            if (!symbolData.lastDate || (item.last_record && item.last_record > symbolData.lastDate)) {
-                symbolData.lastDate = item.last_record;
-            }
-        });
-        
-        // Calculate average coverage per symbol and load health scores
-        symbolMap.forEach(async (symbolData) => {
-            if (symbolData.intervals.length > 0) {
-                const totalCoverage = symbolData.intervals.reduce((sum, i) => sum + i.coverage, 0);
-                symbolData.totalCoverage = totalCoverage / symbolData.intervals.length;
-            }
-            
-            // Load health score for first interval (as a sample)
-            if (symbolData.intervals[0]) {
-                await loadHealthScore(symbolData.symbol, symbolData.intervals[0].interval, symbolData);
-            }
-        });
-        
-        // Update statistics
-        updateStatistics(symbolMap);
-        
-        // Display table
-        displayPairsTable(symbolMap);
-        
-        // Hide loading indicator
-        document.getElementById('loadingIndicator').style.display = 'none';
-        document.getElementById('pairsTable').style.display = 'table';
-    }
-    
-    async function loadHealthScore(symbol, interval, symbolData) {
-        try {
-            const response = await fetch(`/api/gaps/health/${symbol}/${interval}`);
-            const result = await response.json();
-            
-            if (result.status === 'success' && result.data) {
-                symbolData.healthScore = result.data.health_score;
-                symbolData.healthIssues = result.data.issues || [];
-            }
-        } catch (error) {
-            console.error(`Error loading health for ${symbol}:`, error);
+            tbody.innerHTML = filtered.map(item => {
+                const coverage = item.coverage_percent || 0;
+                const statusClass = coverage >= 99 ? 'status-excellent' :
+                                  coverage >= 95 ? 'status-good' :
+                                  coverage >= 80 ? 'status-warning' : 'status-critical';
+                
+                return `
+                    <tr>
+                        <td><strong>${item.symbol}</strong></td>
+                        <td>${item.interval}</td>
+                        <td>
+                            <div class="progress-bar">
+                                <div class="progress-fill" style="width: ${coverage}%">
+                                    ${coverage.toFixed(2)}%
+                                </div>
+                            </div>
+                        </td>
+                        <td>${item.total_records.toLocaleString()}</td>
+                        <td>${item.missing_records.toLocaleString()}</td>
+                        <td>${item.gaps_count}</td>
+                        <td><span class="status-badge ${statusClass}">
+                            ${coverage >= 99 ? 'Excellent' : coverage >= 95 ? 'Good' : coverage >= 80 ? 'Fair' : 'Critical'}
+                        </span></td>
+                        <td>
+                            ${item.gaps_count > 0 ? 
+                                `<button class="btn btn-warning" onclick="fillGap('${item.symbol}', '${item.interval}')">Fill Gaps</button>` :
+                                `<button class="btn btn-secondary" disabled>No Gaps</button>`
+                            }
+                        </td>
+                    </tr>
+                `;
+            }).join('');
         }
-    }
-    
-    function updateStatistics(symbolMap) {
-        const totalPairs = symbolMap.size;
-        const pairsWithGaps = Array.from(symbolMap.values()).filter(s => s.totalMissing > 0).length;
-        const totalMissing = Array.from(symbolMap.values()).reduce((sum, s) => sum + s.totalMissing, 0);
-        const avgCoverage = totalPairs > 0 
-            ? Array.from(symbolMap.values()).reduce((sum, s) => sum + s.totalCoverage, 0) / totalPairs 
-            : 0;
         
-        document.getElementById('totalPairs').textContent = totalPairs;
-        document.getElementById('pairsWithGaps').textContent = pairsWithGaps;
-        document.getElementById('totalMissing').textContent = totalMissing.toLocaleString();
-        document.getElementById('avgCoverage').textContent = avgCoverage.toFixed(1) + '%';
-    }
-    
-    function displayPairsTable(symbolMap) {
-        const tbody = document.getElementById('pairsTableBody');
-        tbody.innerHTML = '';
-        
-        // Sort by coverage (worst first)
-        const sortedSymbols = Array.from(symbolMap.values()).sort((a, b) => a.totalCoverage - b.totalCoverage);
-        
-        sortedSymbols.forEach(symbolData => {
-            const row = document.createElement('tr');
+        // Load indicator coverage data
+        async function loadIndicatorData() {
+            const loading = document.getElementById('indicators-loading');
+            const content = document.getElementById('indicators-content');
             
-            const coverage = symbolData.totalCoverage;
-            let statusClass, statusText;
-            if (coverage >= 95) {
-                statusClass = 'status-excellent';
-                statusText = 'Excellent';
-            } else if (coverage >= 80) {
-                statusClass = 'status-good';
-                statusText = 'Good';
-            } else if (coverage >= 50) {
-                statusClass = 'status-partial';
-                statusText = 'Partial';
-            } else {
-                statusClass = 'status-poor';
-                statusText = 'Poor';
+            loading.style.display = 'block';
+            content.style.display = 'none';
+            
+            try {
+                const response = await fetch('/api/indicators/coverage/all');
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    indicatorData = data.data || [];
+                    renderIndicatorTable();
+                    content.style.display = 'block';
+                } else {
+                    alert('Error loading indicator data: ' + data.message);
+                }
+            } catch (error) {
+                console.error('Error loading indicators:', error);
+                alert('Failed to load indicator coverage data');
+            } finally {
+                loading.style.display = 'none';
+            }
+        }
+        
+        // Load indicator summary
+        async function loadIndicatorSummary() {
+            const loading = document.getElementById('indicator-summary-loading');
+            const content = document.getElementById('indicator-summary-content');
+            
+            loading.style.display = 'block';
+            
+            try {
+                const response = await fetch('/api/indicators/summary');
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    const summary = data.data;
+                    document.getElementById('total-combinations').textContent = summary.total_combinations;
+                    document.getElementById('complete-combinations').textContent = summary.complete_combinations;
+                    document.getElementById('incomplete-combinations').textContent = summary.incomplete_combinations;
+                    document.getElementById('avg-coverage').textContent = summary.average_coverage.toFixed(2) + '%';
+                    
+                    content.style.display = 'block';
+                }
+            } catch (error) {
+                console.error('Error loading summary:', error);
+            } finally {
+                loading.style.display = 'none';
+            }
+        }
+        
+        // Render indicator table
+        function renderIndicatorTable() {
+            const tbody = document.getElementById('indicators-tbody');
+            const search = document.getElementById('indicator-search').value.toLowerCase();
+            const filter = document.getElementById('indicator-filter').value;
+            
+            let filtered = indicatorData.filter(item => {
+                const matchSearch = item.symbol.toLowerCase().includes(search) || 
+                                  item.interval.toLowerCase().includes(search);
+                
+                let matchFilter = true;
+                if (filter === 'incomplete') {
+                    matchFilter = item.coverage_percent < 100;
+                } else if (filter === 'complete') {
+                    matchFilter = item.coverage_percent >= 99.9;
+                }
+                
+                return matchSearch && matchFilter;
+            });
+            
+            tbody.innerHTML = filtered.map(item => {
+                const coverage = item.coverage_percent || 0;
+                const statusClass = coverage >= 99.9 ? 'status-excellent' :
+                                  coverage >= 90 ? 'status-good' :
+                                  coverage >= 50 ? 'status-warning' : 'status-critical';
+                
+                const missingIndicators = item.missing_indicators || [];
+                const missingDetails = missingIndicators.length > 0 ? 
+                    `<div class="indicator-details">${missingIndicators.length} indicators incomplete</div>` : '';
+                
+                return `
+                    <tr>
+                        <td><strong>${item.symbol}</strong></td>
+                        <td>${item.interval}</td>
+                        <td>
+                            <div class="progress-bar">
+                                <div class="progress-fill" style="width: ${coverage}%">
+                                    ${coverage.toFixed(2)}%
+                                </div>
+                            </div>
+                        </td>
+                        <td>${item.total_ohlcv.toLocaleString()}</td>
+                        <td>${item.complete_records.toLocaleString()}</td>
+                        <td>${item.incomplete_records.toLocaleString()}</td>
+                        <td>
+                            ${missingIndicators.length > 0 ? 
+                                `<span class="status-badge status-warning">${missingIndicators.length}</span>` :
+                                `<span class="status-badge status-excellent">Complete</span>`
+                            }
+                            ${missingDetails}
+                        </td>
+                        <td>
+                            ${coverage < 99.9 ? 
+                                `<button class="btn btn-success" onclick="backfillIndicator('${item.symbol}', '${item.interval}')">Backfill</button>` :
+                                `<button class="btn btn-secondary" disabled>Complete</button>`
+                            }
+                        </td>
+                    </tr>
+                `;
+            }).join('');
+        }
+        
+        // Fill gap for specific symbol/interval
+        async function fillGap(symbol, interval) {
+            if (!confirm(`Fill gaps for ${symbol} ${interval}?`)) return;
+            
+            try {
+                const response = await fetch('/api/gaps/auto-fill', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        symbol: symbol,
+                        intervals: [interval],
+                        fill_genuine_gaps: true
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    alert(`Gap fill completed for ${symbol} ${interval}`);
+                    loadGapsData();
+                } else {
+                    alert('Error filling gaps: ' + data.message);
+                }
+            } catch (error) {
+                console.error('Error:', error);
+                alert('Failed to fill gaps');
+            }
+        }
+        
+        // Fill all gaps
+        async function fillAllGaps() {
+            if (!confirm('Fill all gaps? This may take a while.')) return;
+            
+            const pairsWithGaps = gapsData.filter(item => item.gaps_count > 0);
+            
+            if (pairsWithGaps.length === 0) {
+                alert('No gaps to fill!');
+                return;
             }
             
-            // Format dates
-            const fromDate = symbolData.firstDate ? new Date(symbolData.firstDate).toLocaleDateString() : 'N/A';
-            const toDate = symbolData.lastDate ? new Date(symbolData.lastDate).toLocaleDateString() : 'N/A';
+            alert(`Starting gap fill for ${pairsWithGaps.length} pairs...`);
             
-            // Create interval badges
-            const intervalBadges = symbolData.intervals.map(i => 
-                `<span class="interval-badge">${i.interval}</span>`
-            ).join('');
-            
-            // Health indicator
-            const healthIndicator = symbolData.healthScore !== null 
-                ? `<span style="color: ${getHealthColor(symbolData.healthScore)}">❤ ${symbolData.healthScore}</span>`
-                : '';
-            
-            row.innerHTML = `
-                <td><strong>${symbolData.symbol}</strong> ${healthIndicator}</td>
-                <td>${fromDate}</td>
-                <td>${toDate}</td>
-                <td>${intervalBadges}</td>
-                <td>
-                    <div class="progress-bar">
-                        <div class="progress-fill" style="width: ${coverage}%"></div>
-                    </div>
-                    <small>${coverage.toFixed(1)}% (${symbolData.totalMissing.toLocaleString()} missing)</small>
-                </td>
-                <td><span class="status-badge ${statusClass}">${statusText}</span></td>
-                <td>
-                    <button class="action-button" onclick="showDetails('${symbolData.symbol}')">Details</button>
-                    ${symbolData.totalMissing > 0 ? `<button class="action-button secondary" onclick="smartFillGaps('${symbolData.symbol}')">Smart Fill</button>` : ''}
-                </td>
-            `;
-            
-            tbody.appendChild(row);
-        });
-    }
-    
-    function getHealthColor(score) {
-        if (score >= 90) return '#48bb78';
-        if (score >= 70) return '#4299e1';
-        if (score >= 50) return '#ed8936';
-        return '#f56565';
-    }
-    
-    async function showDetails(symbol) {
-        const modal = document.getElementById('gapModal');
-        const modalTitle = document.getElementById('modalTitle');
-        const modalBody = document.getElementById('modalBody');
-        
-        modalTitle.textContent = `${symbol} - Gap Details & Analytics`;
-        modalBody.innerHTML = '<div class="loading"><div class="spinner"></div><p>Loading details...</p></div>';
-        modal.style.display = 'block';
-        
-        // Get data for this symbol
-        const symbolData = gapData.filter(item => item.symbol === symbol);
-        
-        let detailsHTML = '';
-        
-        for (const item of symbolData) {
-            const coverage = item.coverage_percent || 0;
-            const statusClass = coverage >= 95 ? 'status-excellent' : coverage >= 80 ? 'status-good' : coverage >= 50 ? 'status-partial' : 'status-poor';
-            
-            // Get progress and health data
-            const progressData = await fetchProgress(symbol, item.interval);
-            const healthData = await fetchHealth(symbol, item.interval);
-            const prioritizedGaps = await fetchPrioritizedGaps(symbol, item.interval);
-            
-            detailsHTML += `
-                <div class="gap-item">
-                    <h3>${item.interval} <span class="status-badge ${statusClass}">${coverage.toFixed(1)}%</span></h3>
-                    
-                    ${healthData ? `
-                        <div style="background: #fff5f5; padding: 10px; border-radius: 4px; margin: 10px 0; border-left: 3px solid ${getHealthColor(healthData.health_score)}">
-                            <strong>Health Score: ${healthData.health_score}/100</strong> (${healthData.status})
-                            ${healthData.issues.length > 0 ? `
-                                <ul style="margin: 5px 0 0 20px; font-size: 12px;">
-                                    ${healthData.issues.map(issue => `<li>${issue.message}</li>`).join('')}
-                                </ul>
-                            ` : '<p style="margin: 5px 0 0 0; font-size: 12px; color: #48bb78;">✓ No issues detected</p>'}
-                        </div>
-                    ` : ''}
-                    
-                    ${progressData && progressData.missing_records > 0 ? `
-                        <div style="background: #ebf8ff; padding: 10px; border-radius: 4px; margin: 10px 0;">
-                            <strong>⏱ Estimated Time to Complete:</strong> ${progressData.estimated_time_human}
-                            <small style="display: block; margin-top: 5px; color: #718096;">
-                                ${progressData.missing_records.toLocaleString()} records remaining
-                            </small>
-                        </div>
-                    ` : ''}
-                    
-                    <div class="gap-info">
-                        <div class="gap-info-item">
-                            <span class="gap-label">First Record:</span>
-                            <span class="gap-value">${item.first_record ? new Date(item.first_record).toLocaleString() : 'N/A'}</span>
-                        </div>
-                        <div class="gap-info-item">
-                            <span class="gap-label">Last Record:</span>
-                            <span class="gap-value">${item.last_record ? new Date(item.last_record).toLocaleString() : 'N/A'}</span>
-                        </div>
-                        <div class="gap-info-item">
-                            <span class="gap-label">Total Records:</span>
-                            <span class="gap-value">${(item.total_records || 0).toLocaleString()}</span>
-                        </div>
-                        <div class="gap-info-item">
-                            <span class="gap-label">Expected Records:</span>
-                            <span class="gap-value">${(item.expected_records || 0).toLocaleString()}</span>
-                        </div>
-                        <div class="gap-info-item">
-                            <span class="gap-label">Missing Records:</span>
-                            <span class="gap-value">${(item.missing_records || 0).toLocaleString()}</span>
-                        </div>
-                        <div class="gap-info-item">
-                            <span class="gap-label">Number of Gaps:</span>
-                            <span class="gap-value">${(item.gaps || []).length}</span>
-                        </div>
-                    </div>
-            `;
-            
-            if (prioritizedGaps && prioritizedGaps.length > 0) {
-                detailsHTML += '<h4 style="margin-top: 15px; color: #2d3748;">🎯 Priority Gaps (Smartly Sorted):</h4>';
-                prioritizedGaps.slice(0, 10).forEach((gap, idx) => {
-                    const priorityColor = gap.priority_score > 150 ? '#48bb78' : gap.priority_score > 100 ? '#4299e1' : '#ed8936';
-                    detailsHTML += `
-                        <div style="background: #edf2f7; padding: 10px; margin: 5px 0; border-radius: 4px; font-size: 13px; border-left: 3px solid ${priorityColor}">
-                            <strong>#${idx + 1} Priority:</strong> ${gap.priority_score.toFixed(1)} | 
-                            <strong>Age:</strong> ${gap.days_old} days<br>
-                            <strong>Gap:</strong> ${new Date(gap.gap_start).toLocaleString()} → ${new Date(gap.gap_end).toLocaleString()}<br>
-                            <strong>Missing:</strong> ${gap.missing_candles} candles (${gap.duration_hours}h)
-                        </div>
-                    `;
-                });
-                if (prioritizedGaps.length > 10) {
-                    detailsHTML += `<p style="color: #718096; font-size: 13px; margin-top: 5px;">... and ${prioritizedGaps.length - 10} more gaps</p>`;
+            for (const item of pairsWithGaps) {
+                try {
+                    await fetch('/api/gaps/auto-fill', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            symbol: item.symbol,
+                            intervals: [item.interval],
+                            fill_genuine_gaps: true
+                        })
+                    });
+                } catch (error) {
+                    console.error(`Error filling ${item.symbol}:`, error);
                 }
             }
             
-            detailsHTML += '</div>';
+            alert('Gap fill process completed!');
+            loadGapsData();
         }
         
-        modalBody.innerHTML = detailsHTML || '<p>No gap data available</p>';
-    }
-    
-    async function fetchProgress(symbol, interval) {
-        try {
-            const response = await fetch(`/api/gaps/progress/${symbol}/${interval}`);
-            const result = await response.json();
-            return result.status === 'success' ? result.data : null;
-        } catch (error) {
-            console.error('Error fetching progress:', error);
-            return null;
-        }
-    }
-    
-    async function fetchHealth(symbol, interval) {
-        try {
-            const response = await fetch(`/api/gaps/health/${symbol}/${interval}`);
-            const result = await response.json();
-            return result.status === 'success' ? result.data : null;
-        } catch (error) {
-            console.error('Error fetching health:', error);
-            return null;
-        }
-    }
-    
-    async function fetchPrioritizedGaps(symbol, interval) {
-        try {
-            const response = await fetch(`/api/gaps/prioritized/${symbol}/${interval}`);
-            const result = await response.json();
-            return result.status === 'success' ? result.data : null;
-        } catch (error) {
-            console.error('Error fetching prioritized gaps:', error);
-            return null;
-        }
-    }
-    
-    async function smartFillGaps(symbol) {
-        if (!confirm(`Smart fill will automatically prioritize and fill the most important gaps for ${symbol}. Continue?`)) {
-            return;
-        }
-        
-        try {
-            const response = await fetch(`/api/gaps/smart-fill/${symbol}`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' }
-            });
+        // Backfill indicator for specific symbol/interval
+        async function backfillIndicator(symbol, interval) {
+            if (!confirm(`Backfill indicators for ${symbol} ${interval}?`)) return;
             
-            const result = await response.json();
+            const btn = event.target;
+            btn.disabled = true;
+            btn.textContent = 'Processing...';
             
-            if (result.status === 'success') {
-                alert(`Smart fill completed for ${symbol}!\\n\\n` + 
-                      result.data.map(r => `${r.interval}: ${r.gaps_filled}/${r.total_gaps} filled`).join('\\n'));
+            try {
+                const response = await fetch(`/api/indicators/backfill/${symbol}/${interval}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ batch_size: 200 })
+                });
                 
-                // Reload data
-                setTimeout(loadGapData, 3000);
-            } else {
-                alert('Error: ' + result.message);
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    const result = data.data;
+                    alert(`Backfill completed!\nCoverage: ${result.coverage_before}% → ${result.coverage_after}%\nIndicators added: ${result.indicators_added}`);
+                    loadIndicatorData();
+                    loadIndicatorSummary();
+                } else {
+                    alert('Error backfilling: ' + data.message);
+                }
+            } catch (error) {
+                console.error('Error:', error);
+                alert('Failed to backfill indicators');
+            } finally {
+                btn.disabled = false;
+                btn.textContent = 'Backfill';
             }
-        } catch (error) {
-            alert('Error filling gaps: ' + error.message);
         }
-    }
-    
-    function closeModal() {
-        document.getElementById('gapModal').style.display = 'none';
-    }
-    
-    function showError(message) {
-        document.getElementById('loadingIndicator').innerHTML = `
-            <p style="color: #e53e3e; font-weight: bold;">${message}</p>
-        `;
-    }
-    
-    // Close modal when clicking outside
-    window.onclick = function(event) {
-        const modal = document.getElementById('gapModal');
-        if (event.target == modal) {
-            closeModal();
+        
+        // Backfill all incomplete indicators
+        async function backfillAllIndicators() {
+            if (!confirm('Backfill all incomplete indicators? This may take a while.')) return;
+            
+            try {
+                const response = await fetch('/api/indicators/backfill-all', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        batch_size: 200,
+                        min_coverage_threshold: 99.9
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.status === 'success') {
+                    const summary = data.data;
+                    alert(`Backfill completed!\nProcessed: ${summary.processed}\nSuccessful: ${summary.successful}\nFailed: ${summary.failed}`);
+                    loadIndicatorData();
+                    loadIndicatorSummary();
+                } else {
+                    alert('Error: ' + data.message);
+                }
+            } catch (error) {
+                console.error('Error:', error);
+                alert('Failed to backfill indicators');
+            }
         }
-    }
-    
-    // Load data on page load
-    loadGapData();
-    
-    // Auto-refresh every 30 seconds
-    setInterval(loadGapData, 30000);
-</script>
+        
+        // Search and filter handlers
+        document.addEventListener('DOMContentLoaded', () => {
+            document.getElementById('gap-search')?.addEventListener('input', renderGapsTable);
+            document.getElementById('gap-filter')?.addEventListener('change', renderGapsTable);
+            document.getElementById('indicator-search')?.addEventListener('input', renderIndicatorTable);
+            document.getElementById('indicator-filter')?.addEventListener('change', renderIndicatorTable);
+            
+            // Load initial data
+            loadGapsData();
+        });
+    </script>
 </body>
 </html>
     """
diff --git a/variables.env b/variables.env.example
similarity index 100%
rename from variables.env
rename to variables.env.example
