diff --git a/src/Managing.Api/Controllers/BacktestController.cs b/src/Managing.Api/Controllers/BacktestController.cs
index 10f5f22a..081e3164 100644
--- a/src/Managing.Api/Controllers/BacktestController.cs
+++ b/src/Managing.Api/Controllers/BacktestController.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
 using Managing.Api.Models.Requests;
 using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Shared;
 using Managing.Application.Hubs;
 using Managing.Domain.Backtests;
 using Managing.Domain.Bots;
@@ -10,6 +11,7 @@ using Managing.Domain.Strategies;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SignalR;
+using static Managing.Common.Enums;
 using MoneyManagementRequest = Managing.Domain.Backtests.MoneyManagementRequest;
 
 namespace Managing.Api.Controllers;
@@ -231,8 +233,17 @@ public class BacktestController : BaseController
     public async Task<ActionResult<PaginatedBacktestsResponse>> GetBacktestsPaginated(
         int page = 1,
         int pageSize = 50,
-        string sortBy = "score",
-        string sortOrder = "desc")
+        BacktestSortableColumn sortBy = BacktestSortableColumn.Score,
+        string sortOrder = "desc",
+        [FromQuery] double? scoreMin = null,
+        [FromQuery] double? scoreMax = null,
+        [FromQuery] int? winrateMin = null,
+        [FromQuery] int? winrateMax = null,
+        [FromQuery] decimal? maxDrawdownMax = null,
+        [FromQuery] string? tickers = null,
+        [FromQuery] string? indicators = null,
+        [FromQuery] double? durationMinDays = null,
+        [FromQuery] double? durationMaxDays = null)
     {
         var user = await GetUser();
 
@@ -251,8 +262,65 @@ public class BacktestController : BaseController
             return BadRequest("Sort order must be 'asc' or 'desc'");
         }
 
+        // Validate score and winrate ranges [0,100]
+        if (scoreMin.HasValue && (scoreMin < 0 || scoreMin > 100))
+        {
+            return BadRequest("scoreMin must be between 0 and 100");
+        }
+        if (scoreMax.HasValue && (scoreMax < 0 || scoreMax > 100))
+        {
+            return BadRequest("scoreMax must be between 0 and 100");
+        }
+        if (winrateMin.HasValue && (winrateMin < 0 || winrateMin > 100))
+        {
+            return BadRequest("winrateMin must be between 0 and 100");
+        }
+        if (winrateMax.HasValue && (winrateMax < 0 || winrateMax > 100))
+        {
+            return BadRequest("winrateMax must be between 0 and 100");
+        }
+
+        if (scoreMin.HasValue && scoreMax.HasValue && scoreMin > scoreMax)
+        {
+            return BadRequest("scoreMin must be less than or equal to scoreMax");
+        }
+        if (winrateMin.HasValue && winrateMax.HasValue && winrateMin > winrateMax)
+        {
+            return BadRequest("winrateMin must be less than or equal to winrateMax");
+        }
+        if (maxDrawdownMax.HasValue && maxDrawdownMax < 0)
+        {
+            return BadRequest("maxDrawdownMax must be greater than or equal to 0");
+        }
+
+        // Parse multi-selects if provided (comma-separated). Currently unused until repository wiring.
+        var tickerList = string.IsNullOrWhiteSpace(tickers)
+            ? Array.Empty<string>()
+            : tickers.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var indicatorList = string.IsNullOrWhiteSpace(indicators)
+            ? Array.Empty<string>()
+            : indicators.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var filter = new BacktestsFilter
+        {
+            ScoreMin = scoreMin,
+            ScoreMax = scoreMax,
+            WinrateMin = winrateMin,
+            WinrateMax = winrateMax,
+            MaxDrawdownMax = maxDrawdownMax,
+            Tickers = tickerList,
+            Indicators = indicatorList,
+            DurationMin = durationMinDays.HasValue ? TimeSpan.FromDays(durationMinDays.Value) : (TimeSpan?)null,
+            DurationMax = durationMaxDays.HasValue ? TimeSpan.FromDays(durationMaxDays.Value) : (TimeSpan?)null
+        };
+
         var (backtests, totalCount) =
-            await _backtester.GetBacktestsByUserPaginatedAsync(user, page, pageSize, sortBy, sortOrder);
+            await _backtester.GetBacktestsByUserPaginatedAsync(
+                user,
+                page,
+                pageSize,
+                sortBy,
+                sortOrder,
+                filter);
         var totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);
 
         var response = new PaginatedBacktestsResponse
diff --git a/src/Managing.Application.Abstractions/Repositories/IBacktestRepository.cs b/src/Managing.Application.Abstractions/Repositories/IBacktestRepository.cs
index 4063df62..eda2bb96 100644
--- a/src/Managing.Application.Abstractions/Repositories/IBacktestRepository.cs
+++ b/src/Managing.Application.Abstractions/Repositories/IBacktestRepository.cs
@@ -1,4 +1,6 @@
-using Managing.Domain.Backtests;
+using Managing.Application.Abstractions.Shared;
+using Managing.Common;
+using Managing.Domain.Backtests;
 using Managing.Domain.Users;
 
 namespace Managing.Application.Abstractions.Repositories;
@@ -18,11 +20,21 @@ public interface IBacktestRepository
         int page,
         int pageSize, string sortBy = "score", string sortOrder = "desc");
 
-    (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(User user, int page,
-        int pageSize, string sortBy = "score", string sortOrder = "desc");
+    (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(
+        User user,
+        int page,
+        int pageSize,
+        Enums.BacktestSortableColumn sortBy = Enums.BacktestSortableColumn.Score,
+        string sortOrder = "desc",
+        BacktestsFilter? filter = null);
 
-    Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(User user, int page,
-        int pageSize, string sortBy = "score", string sortOrder = "desc");
+    Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(
+        User user,
+        int page,
+        int pageSize,
+        Enums.BacktestSortableColumn sortBy = Enums.BacktestSortableColumn.Score,
+        string sortOrder = "desc",
+        BacktestsFilter? filter = null);
 
     Task<Backtest> GetBacktestByIdForUserAsync(User user, string id);
     Task DeleteBacktestByIdForUserAsync(User user, string id);
diff --git a/src/Managing.Application.Abstractions/Services/IBacktester.cs b/src/Managing.Application.Abstractions/Services/IBacktester.cs
index b89baba0..f1b4d085 100644
--- a/src/Managing.Application.Abstractions/Services/IBacktester.cs
+++ b/src/Managing.Application.Abstractions/Services/IBacktester.cs
@@ -1,4 +1,6 @@
-using Managing.Domain.Backtests;
+using Managing.Application.Abstractions.Shared;
+using Managing.Common;
+using Managing.Domain.Backtests;
 using Managing.Domain.Bots;
 using Managing.Domain.Candles;
 using Managing.Domain.Users;
@@ -64,9 +66,22 @@ namespace Managing.Application.Abstractions.Services
         Task<bool> DeleteBacktestByUserAsync(User user, string id);
         Task<bool> DeleteBacktestsByIdsForUserAsync(User user, IEnumerable<string> ids);
         bool DeleteBacktestsByUser(User user);
+        (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(
+            User user,
+            int page,
+            int pageSize,
+            Enums.BacktestSortableColumn sortBy,
+            string sortOrder = "desc",
+            BacktestsFilter? filter = null);
+
+        Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(
+            User user,
+            int page,
+            int pageSize,
+            Enums.BacktestSortableColumn sortBy,
+            string sortOrder = "desc",
+            BacktestsFilter? filter = null);
         Task<bool> DeleteBacktestsByRequestIdAsync(Guid requestId);
-        (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(User user, int page, int pageSize, string sortBy = "score", string sortOrder = "desc");
-        Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(User user, int page, int pageSize, string sortBy = "score", string sortOrder = "desc");
 
         // Bundle backtest methods
         void InsertBundleBacktestRequestForUser(User user, BundleBacktestRequest bundleRequest);
diff --git a/src/Managing.Application.Abstractions/Shared/BacktestsFilter.cs b/src/Managing.Application.Abstractions/Shared/BacktestsFilter.cs
new file mode 100644
index 00000000..93712a53
--- /dev/null
+++ b/src/Managing.Application.Abstractions/Shared/BacktestsFilter.cs
@@ -0,0 +1,16 @@
+namespace Managing.Application.Abstractions.Shared;
+
+public class BacktestsFilter
+{
+    public double? ScoreMin { get; set; }
+    public double? ScoreMax { get; set; }
+    public int? WinrateMin { get; set; }
+    public int? WinrateMax { get; set; }
+    public decimal? MaxDrawdownMax { get; set; }
+    public IEnumerable<string>? Tickers { get; set; }
+    public IEnumerable<string>? Indicators { get; set; }
+    public TimeSpan? DurationMin { get; set; }
+    public TimeSpan? DurationMax { get; set; }
+}
+
+
diff --git a/src/Managing.Application/Backtests/Backtester.cs b/src/Managing.Application/Backtests/Backtester.cs
index ec8e52fe..8d1c2faa 100644
--- a/src/Managing.Application/Backtests/Backtester.cs
+++ b/src/Managing.Application/Backtests/Backtester.cs
@@ -2,6 +2,7 @@
 using Managing.Application.Abstractions.Grains;
 using Managing.Application.Abstractions.Repositories;
 using Managing.Application.Abstractions.Services;
+using Managing.Application.Abstractions.Shared;
 using Managing.Application.Hubs;
 using Managing.Core;
 using Managing.Domain.Accounts;
@@ -415,19 +416,29 @@ namespace Managing.Application.Backtests
             }
         }
 
-        public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(User user, int page,
-            int pageSize, string sortBy = "score", string sortOrder = "desc")
+        public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(
+            User user,
+            int page,
+            int pageSize,
+            BacktestSortableColumn sortBy,
+            string sortOrder = "desc",
+            BacktestsFilter? filter = null)
         {
             var (backtests, totalCount) =
-                _backtestRepository.GetBacktestsByUserPaginated(user, page, pageSize, sortBy, sortOrder);
+                _backtestRepository.GetBacktestsByUserPaginated(user, page, pageSize, sortBy, sortOrder, filter);
             return (backtests, totalCount);
         }
 
         public async Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(
-            User user, int page, int pageSize, string sortBy = "score", string sortOrder = "desc")
+            User user,
+            int page,
+            int pageSize,
+            BacktestSortableColumn sortBy,
+            string sortOrder = "desc",
+            BacktestsFilter? filter = null)
         {
             var (backtests, totalCount) =
-                await _backtestRepository.GetBacktestsByUserPaginatedAsync(user, page, pageSize, sortBy, sortOrder);
+                await _backtestRepository.GetBacktestsByUserPaginatedAsync(user, page, pageSize, sortBy, sortOrder, filter);
             return (backtests, totalCount);
         }
 
diff --git a/src/Managing.Common/Enums.cs b/src/Managing.Common/Enums.cs
index e28f766b..cd02d742 100644
--- a/src/Managing.Common/Enums.cs
+++ b/src/Managing.Common/Enums.cs
@@ -504,6 +504,25 @@ public static class Enums
         TotalBalance
     }
 
+    /// <summary>
+    /// Sortable columns for backtests pagination endpoints
+    /// </summary>
+    public enum BacktestSortableColumn
+    {
+        Score,
+        FinalPnl,
+        WinRate,
+        GrowthPercentage,
+        HodlPercentage,
+        Duration,
+        Timeframe,
+        IndicatorsCount,
+        MaxDrawdown,
+        Fees,
+        SharpeRatio,
+        Ticker
+    }
+
     /// <summary>
     /// Event types for agent summary updates
     /// </summary>
diff --git a/src/Managing.Domain/Backtests/LightBacktest.cs b/src/Managing.Domain/Backtests/LightBacktest.cs
index a0bdbbf0..997403e3 100644
--- a/src/Managing.Domain/Backtests/LightBacktest.cs
+++ b/src/Managing.Domain/Backtests/LightBacktest.cs
@@ -24,4 +24,5 @@ public class LightBacktest
     [Id(11)] public double Score { get; set; }
     [Id(12)] public string ScoreMessage { get; set; } = string.Empty;
     [Id(13)] public object Metadata { get; set; }
+    [Id(14)] public string Ticker { get; set; } = string.Empty;
 } 
\ No newline at end of file
diff --git a/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.Designer.cs b/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.Designer.cs
new file mode 100644
index 00000000..74797be0
--- /dev/null
+++ b/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.Designer.cs
@@ -0,0 +1,1536 @@
+// <auto-generated />
+using System;
+using Managing.Infrastructure.Databases.PostgreSql;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Managing.Infrastructure.Databases.Migrations
+{
+    [DbContext(typeof(ManagingDbContext))]
+    [Migration("20251014092228_BacktestFiltersDenormalization")]
+    partial class BacktestFiltersDenormalization
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AccountEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Exchange")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsGmxInitialized")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("Secret")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AgentSummaryEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ActiveStrategiesCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AgentName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("BacktestCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Losses")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime?>("Runtime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("TotalBalance")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("TotalFees")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("TotalPnL")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TotalROI")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TotalVolume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Wins")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgentName")
+                        .IsUnique();
+
+                    b.HasIndex("TotalPnL");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("AgentSummaries");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BacktestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConfigJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<TimeSpan>("Duration")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Fees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("FinalPnl")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("GrowthPercentage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("HodlPercentage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Identifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("IndicatorsCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IndicatorsCsv")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("MaxDrawdown")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
+                    b.Property<TimeSpan>("MaxDrawdownRecoveryTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
+                    b.Property<string>("Metadata")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MoneyManagementJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("PositionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("RequestId")
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Score")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ScoreMessage")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("SharpeRatio")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
+                    b.Property<string>("SignalsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("StatisticsJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("Timeframe")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WinRate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("RequestId");
+
+                    b.HasIndex("Score");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RequestId", "Score");
+
+                    b.HasIndex("UserId", "IndicatorsCount");
+
+                    b.HasIndex("UserId", "IndicatorsCsv");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.HasIndex("UserId", "Score");
+
+                    b.HasIndex("UserId", "Ticker");
+
+                    b.HasIndex("UserId", "Timeframe");
+
+                    b.ToTable("Backtests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BotEntity", b =>
+                {
+                    b.Property<Guid>("Identifier")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("AccumulatedRunTimeSeconds")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Fees")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime?>("LastStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastStopTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LongPositionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("Pnl")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("Roi")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<int>("ShortPositionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartupTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TradeLosses")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TradeWins")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Volume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.HasKey("Identifier");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Bots");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BundleBacktestRequestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CompletedBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentBacktest")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("DateTimeRangesJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EstimatedTimeRemainingSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FailedBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MoneyManagementVariantsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("ProgressInfo")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RequestId")
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ResultsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TickerVariantsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UniversalConfigJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "CreatedAt");
+
+                    b.ToTable("BundleBacktestRequests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.FundingRateEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Direction")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Exchange")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("OpenInterest")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Exchange");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("Exchange", "Date");
+
+                    b.HasIndex("Ticker", "Exchange");
+
+                    b.HasIndex("Ticker", "Exchange", "Date")
+                        .IsUnique();
+
+                    b.ToTable("FundingRates");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.GeneticRequestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Balance")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("BestChromosome")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<double?>("BestFitness")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("BestFitnessSoFar")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("BestIndividual")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CrossoverMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("CurrentGeneration")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("EligibleIndicatorsJson")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<int>("ElitismPercentage")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<int>("Generations")
+                        .HasColumnType("integer");
+
+                    b.Property<double>("MaxTakeProfit")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MutationMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<double>("MutationRate")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("PopulationSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProgressInfo")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("RequestId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("SelectionMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GeneticRequests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("CyclePeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("FastPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumHistory")
+                        .HasColumnType("integer");
+
+                    b.Property<double?>("Multiplier")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int?>("Period")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SignalPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SignalType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("SlowPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SmoothPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("StochPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.ToTable("Indicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.MoneyManagementEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Leverage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("StopLoss")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TakeProfit")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserName");
+
+                    b.HasIndex("UserName", "Name");
+
+                    b.ToTable("MoneyManagements");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.PositionEntity", b =>
+                {
+                    b.Property<Guid>("Identifier")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccountId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("GasFees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Initiator")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("InitiatorIdentifier")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("MoneyManagementJson")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int?>("OpenTradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OriginDirection")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ProfitAndLoss")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("SignalIdentifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("StopLossTradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TakeProfit1TradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TakeProfit2TradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("UiFees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Identifier");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("InitiatorIdentifier");
+
+                    b.HasIndex("OpenTradeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StopLossTradeId");
+
+                    b.HasIndex("TakeProfit1TradeId");
+
+                    b.HasIndex("TakeProfit2TradeId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Identifier");
+
+                    b.ToTable("Positions");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LoopbackPeriod")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.ToTable("Scenarios");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioIndicatorEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("IndicatorId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ScenarioId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IndicatorId");
+
+                    b.HasIndex("ScenarioId", "IndicatorId")
+                        .IsUnique();
+
+                    b.ToTable("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SignalEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CandleJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Confidence")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Identifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("IndicatorName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("SignalType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Identifier");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Date");
+
+                    b.HasIndex("Identifier", "Date", "UserId")
+                        .IsUnique();
+
+                    b.ToTable("Signals");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SpotlightOverviewEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Identifier")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScenarioCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SpotlightsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateTime");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("DateTime", "ScenarioCount");
+
+                    b.ToTable("SpotlightOverviews");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SynthMinersLeaderboardEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Asset")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("CacheKey")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBacktest")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MinersData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("SignalDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("TimeIncrement")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CacheKey")
+                        .IsUnique();
+
+                    b.ToTable("SynthMinersLeaderboards");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SynthPredictionEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Asset")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("CacheKey")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBacktest")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MinerUid")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PredictionData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("SignalDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("TimeIncrement")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TimeLength")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CacheKey")
+                        .IsUnique();
+
+                    b.ToTable("SynthPredictions");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TopVolumeTickerEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Exchange")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Volume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Exchange");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("Date", "Rank");
+
+                    b.HasIndex("Exchange", "Date");
+
+                    b.ToTable("TopVolumeTickers");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExchangeOrderId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("Leverage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Price")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TradeType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("ExchangeOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("Trades");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TraderEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("AverageLoss")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("AverageWin")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBestTrader")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("Pnl")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Roi")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int>("TradeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Winrate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("IsBestTrader");
+
+                    b.HasIndex("Pnl");
+
+                    b.HasIndex("Roi");
+
+                    b.HasIndex("Winrate");
+
+                    b.HasIndex("Address", "IsBestTrader")
+                        .IsUnique();
+
+                    b.HasIndex("IsBestTrader", "Roi");
+
+                    b.HasIndex("IsBestTrader", "Winrate");
+
+                    b.ToTable("Traders");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgentName")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("AvatarUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("TelegramChannel")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgentName");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.WorkerEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<long>("DelayTicks")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ExecutionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastRunTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("WorkerType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkerType")
+                        .IsUnique();
+
+                    b.ToTable("Workers");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AccountEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AgentSummaryEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BacktestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BotEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BundleBacktestRequestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.GeneticRequestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.MoneyManagementEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.PositionEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "OpenTrade")
+                        .WithMany()
+                        .HasForeignKey("OpenTradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "StopLossTrade")
+                        .WithMany()
+                        .HasForeignKey("StopLossTradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "TakeProfit1Trade")
+                        .WithMany()
+                        .HasForeignKey("TakeProfit1TradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "TakeProfit2Trade")
+                        .WithMany()
+                        .HasForeignKey("TakeProfit2TradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("OpenTrade");
+
+                    b.Navigation("StopLossTrade");
+
+                    b.Navigation("TakeProfit1Trade");
+
+                    b.Navigation("TakeProfit2Trade");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioIndicatorEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", "Indicator")
+                        .WithMany("ScenarioIndicators")
+                        .HasForeignKey("IndicatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", "Scenario")
+                        .WithMany("ScenarioIndicators")
+                        .HasForeignKey("ScenarioId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Indicator");
+
+                    b.Navigation("Scenario");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SignalEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.Navigation("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.Navigation("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.cs b/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.cs
new file mode 100644
index 00000000..64ba8edd
--- /dev/null
+++ b/src/Managing.Infrastructure.Database/Migrations/20251014092228_BacktestFiltersDenormalization.cs
@@ -0,0 +1,165 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Managing.Infrastructure.Databases.Migrations
+{
+    /// <inheritdoc />
+    public partial class BacktestFiltersDenormalization : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<TimeSpan>(
+                name: "Duration",
+                table: "Backtests",
+                type: "interval",
+                nullable: false,
+                defaultValue: new TimeSpan(0, 0, 0, 0, 0));
+
+            migrationBuilder.AddColumn<int>(
+                name: "IndicatorsCount",
+                table: "Backtests",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "IndicatorsCsv",
+                table: "Backtests",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "MaxDrawdown",
+                table: "Backtests",
+                type: "numeric(18,8)",
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<TimeSpan>(
+                name: "MaxDrawdownRecoveryTime",
+                table: "Backtests",
+                type: "interval",
+                nullable: false,
+                defaultValue: new TimeSpan(0, 0, 0, 0, 0));
+
+            migrationBuilder.AddColumn<string>(
+                name: "Name",
+                table: "Backtests",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "SharpeRatio",
+                table: "Backtests",
+                type: "numeric(18,8)",
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Ticker",
+                table: "Backtests",
+                type: "character varying(32)",
+                maxLength: 32,
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<int>(
+                name: "Timeframe",
+                table: "Backtests",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_IndicatorsCount",
+                table: "Backtests",
+                columns: new[] { "UserId", "IndicatorsCount" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_IndicatorsCsv",
+                table: "Backtests",
+                columns: new[] { "UserId", "IndicatorsCsv" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_Name",
+                table: "Backtests",
+                columns: new[] { "UserId", "Name" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_Ticker",
+                table: "Backtests",
+                columns: new[] { "UserId", "Ticker" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_Timeframe",
+                table: "Backtests",
+                columns: new[] { "UserId", "Timeframe" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_IndicatorsCount",
+                table: "Backtests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_IndicatorsCsv",
+                table: "Backtests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_Name",
+                table: "Backtests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_Ticker",
+                table: "Backtests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_Timeframe",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "Duration",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "IndicatorsCount",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "IndicatorsCsv",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "MaxDrawdown",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "MaxDrawdownRecoveryTime",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "Name",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "SharpeRatio",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "Ticker",
+                table: "Backtests");
+
+            migrationBuilder.DropColumn(
+                name: "Timeframe",
+                table: "Backtests");
+        }
+    }
+}
diff --git a/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.Designer.cs b/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.Designer.cs
new file mode 100644
index 00000000..c474ba97
--- /dev/null
+++ b/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.Designer.cs
@@ -0,0 +1,1532 @@
+// <auto-generated />
+using System;
+using Managing.Infrastructure.Databases.PostgreSql;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Managing.Infrastructure.Databases.Migrations
+{
+    [DbContext(typeof(ManagingDbContext))]
+    [Migration("20251014092447_RemoveIndicatorIndexes")]
+    partial class RemoveIndicatorIndexes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AccountEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Exchange")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsGmxInitialized")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("Secret")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AgentSummaryEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ActiveStrategiesCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AgentName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("BacktestCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Losses")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime?>("Runtime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("TotalBalance")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("TotalFees")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("TotalPnL")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TotalROI")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TotalVolume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Wins")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgentName")
+                        .IsUnique();
+
+                    b.HasIndex("TotalPnL");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("AgentSummaries");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BacktestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConfigJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<TimeSpan>("Duration")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Fees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("FinalPnl")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("GrowthPercentage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("HodlPercentage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Identifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("IndicatorsCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IndicatorsCsv")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("MaxDrawdown")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
+                    b.Property<TimeSpan>("MaxDrawdownRecoveryTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
+                    b.Property<string>("Metadata")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MoneyManagementJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("PositionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("RequestId")
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Score")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ScoreMessage")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("SharpeRatio")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
+                    b.Property<string>("SignalsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("StatisticsJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("Timeframe")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WinRate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("RequestId");
+
+                    b.HasIndex("Score");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RequestId", "Score");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.HasIndex("UserId", "Score");
+
+                    b.HasIndex("UserId", "Ticker");
+
+                    b.HasIndex("UserId", "Timeframe");
+
+                    b.ToTable("Backtests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BotEntity", b =>
+                {
+                    b.Property<Guid>("Identifier")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("AccumulatedRunTimeSeconds")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Fees")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<DateTime?>("LastStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastStopTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LongPositionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("Pnl")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<decimal>("Roi")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.Property<int>("ShortPositionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartupTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TradeLosses")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TradeWins")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Volume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("numeric(18,8)");
+
+                    b.HasKey("Identifier");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Bots");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BundleBacktestRequestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CompletedBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentBacktest")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("DateTimeRangesJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EstimatedTimeRemainingSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FailedBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MoneyManagementVariantsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("ProgressInfo")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RequestId")
+                        .HasMaxLength(255)
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ResultsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TickerVariantsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalBacktests")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UniversalConfigJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "CreatedAt");
+
+                    b.ToTable("BundleBacktestRequests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.FundingRateEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Direction")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Exchange")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("OpenInterest")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Exchange");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("Exchange", "Date");
+
+                    b.HasIndex("Ticker", "Exchange");
+
+                    b.HasIndex("Ticker", "Exchange", "Date")
+                        .IsUnique();
+
+                    b.ToTable("FundingRates");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.GeneticRequestEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Balance")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("BestChromosome")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<double?>("BestFitness")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("BestFitnessSoFar")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("BestIndividual")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CrossoverMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("CurrentGeneration")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("EligibleIndicatorsJson")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<int>("ElitismPercentage")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<int>("Generations")
+                        .HasColumnType("integer");
+
+                    b.Property<double>("MaxTakeProfit")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MutationMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<double>("MutationRate")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("PopulationSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProgressInfo")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("RequestId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("SelectionMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GeneticRequests");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("CyclePeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("FastPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinimumHistory")
+                        .HasColumnType("integer");
+
+                    b.Property<double?>("Multiplier")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int?>("Period")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SignalPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SignalType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("SlowPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SmoothPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("StochPeriods")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.ToTable("Indicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.MoneyManagementEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Leverage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("StopLoss")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("TakeProfit")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserName");
+
+                    b.HasIndex("UserName", "Name");
+
+                    b.ToTable("MoneyManagements");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.PositionEntity", b =>
+                {
+                    b.Property<Guid>("Identifier")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccountId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("GasFees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Initiator")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("InitiatorIdentifier")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("MoneyManagementJson")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("NetPnL")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int?>("OpenTradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OriginDirection")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ProfitAndLoss")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("SignalIdentifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("StopLossTradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TakeProfit1TradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TakeProfit2TradeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("UiFees")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Identifier");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("InitiatorIdentifier");
+
+                    b.HasIndex("OpenTradeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StopLossTradeId");
+
+                    b.HasIndex("TakeProfit1TradeId");
+
+                    b.HasIndex("TakeProfit2TradeId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Identifier");
+
+                    b.ToTable("Positions");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LoopbackPeriod")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Name");
+
+                    b.ToTable("Scenarios");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioIndicatorEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("IndicatorId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ScenarioId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IndicatorId");
+
+                    b.HasIndex("ScenarioId", "IndicatorId")
+                        .IsUnique();
+
+                    b.ToTable("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SignalEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CandleJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Confidence")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Identifier")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("IndicatorName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("SignalType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Timeframe")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Identifier");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Date");
+
+                    b.HasIndex("Identifier", "Date", "UserId")
+                        .IsUnique();
+
+                    b.ToTable("Signals");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SpotlightOverviewEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Identifier")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScenarioCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SpotlightsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateTime");
+
+                    b.HasIndex("Identifier")
+                        .IsUnique();
+
+                    b.HasIndex("DateTime", "ScenarioCount");
+
+                    b.ToTable("SpotlightOverviews");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SynthMinersLeaderboardEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Asset")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("CacheKey")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBacktest")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MinersData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("SignalDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("TimeIncrement")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CacheKey")
+                        .IsUnique();
+
+                    b.ToTable("SynthMinersLeaderboards");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SynthPredictionEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Asset")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("CacheKey")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBacktest")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MinerUid")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PredictionData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("SignalDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("TimeIncrement")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TimeLength")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CacheKey")
+                        .IsUnique();
+
+                    b.ToTable("SynthPredictions");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TopVolumeTickerEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Exchange")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Ticker")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Volume")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("Exchange");
+
+                    b.HasIndex("Ticker");
+
+                    b.HasIndex("Date", "Rank");
+
+                    b.HasIndex("Exchange", "Date");
+
+                    b.ToTable("TopVolumeTickers");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExchangeOrderId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("Leverage")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Price")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TradeType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.HasIndex("ExchangeOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("Trades");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.TraderEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<decimal>("AverageLoss")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("AverageWin")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsBestTrader")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("Pnl")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<decimal>("Roi")
+                        .HasPrecision(18, 8)
+                        .HasColumnType("decimal(18,8)");
+
+                    b.Property<int>("TradeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Winrate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("IsBestTrader");
+
+                    b.HasIndex("Pnl");
+
+                    b.HasIndex("Roi");
+
+                    b.HasIndex("Winrate");
+
+                    b.HasIndex("Address", "IsBestTrader")
+                        .IsUnique();
+
+                    b.HasIndex("IsBestTrader", "Roi");
+
+                    b.HasIndex("IsBestTrader", "Winrate");
+
+                    b.ToTable("Traders");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgentName")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("AvatarUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("TelegramChannel")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgentName");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.WorkerEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<long>("DelayTicks")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ExecutionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastRunTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("WorkerType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkerType")
+                        .IsUnique();
+
+                    b.ToTable("Workers");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AccountEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.AgentSummaryEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BacktestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BotEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.BundleBacktestRequestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.GeneticRequestEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.MoneyManagementEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.PositionEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "OpenTrade")
+                        .WithMany()
+                        .HasForeignKey("OpenTradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "StopLossTrade")
+                        .WithMany()
+                        .HasForeignKey("StopLossTradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "TakeProfit1Trade")
+                        .WithMany()
+                        .HasForeignKey("TakeProfit1TradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.TradeEntity", "TakeProfit2Trade")
+                        .WithMany()
+                        .HasForeignKey("TakeProfit2TradeId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("OpenTrade");
+
+                    b.Navigation("StopLossTrade");
+
+                    b.Navigation("TakeProfit1Trade");
+
+                    b.Navigation("TakeProfit2Trade");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioIndicatorEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", "Indicator")
+                        .WithMany("ScenarioIndicators")
+                        .HasForeignKey("IndicatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", "Scenario")
+                        .WithMany("ScenarioIndicators")
+                        .HasForeignKey("ScenarioId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Indicator");
+
+                    b.Navigation("Scenario");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.SignalEntity", b =>
+                {
+                    b.HasOne("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.IndicatorEntity", b =>
+                {
+                    b.Navigation("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.ScenarioEntity", b =>
+                {
+                    b.Navigation("ScenarioIndicators");
+                });
+
+            modelBuilder.Entity("Managing.Infrastructure.Databases.PostgreSql.Entities.UserEntity", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.cs b/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.cs
new file mode 100644
index 00000000..48be48d9
--- /dev/null
+++ b/src/Managing.Infrastructure.Database/Migrations/20251014092447_RemoveIndicatorIndexes.cs
@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Managing.Infrastructure.Databases.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemoveIndicatorIndexes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_IndicatorsCount",
+                table: "Backtests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Backtests_UserId_IndicatorsCsv",
+                table: "Backtests");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_IndicatorsCount",
+                table: "Backtests",
+                columns: new[] { "UserId", "IndicatorsCount" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Backtests_UserId_IndicatorsCsv",
+                table: "Backtests",
+                columns: new[] { "UserId", "IndicatorsCsv" });
+        }
+    }
+}
diff --git a/src/Managing.Infrastructure.Database/Migrations/ManagingDbContextModelSnapshot.cs b/src/Managing.Infrastructure.Database/Migrations/ManagingDbContextModelSnapshot.cs
index 132ff0c3..e6f46757 100644
--- a/src/Managing.Infrastructure.Database/Migrations/ManagingDbContextModelSnapshot.cs
+++ b/src/Managing.Infrastructure.Database/Migrations/ManagingDbContextModelSnapshot.cs
@@ -157,6 +157,11 @@ namespace Managing.Infrastructure.Databases.Migrations
                     b.Property<DateTime>("CreatedAt")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<TimeSpan>("Duration")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
                     b.Property<DateTime>("EndDate")
                         .HasColumnType("timestamp with time zone");
 
@@ -177,6 +182,23 @@ namespace Managing.Infrastructure.Databases.Migrations
                         .HasMaxLength(255)
                         .HasColumnType("character varying(255)");
 
+                    b.Property<int>("IndicatorsCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IndicatorsCsv")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("MaxDrawdown")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
+                    b.Property<TimeSpan>("MaxDrawdownRecoveryTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("interval")
+                        .HasDefaultValue(new TimeSpan(0, 0, 0, 0, 0));
+
                     b.Property<string>("Metadata")
                         .HasColumnType("text");
 
@@ -184,6 +206,11 @@ namespace Managing.Infrastructure.Databases.Migrations
                         .IsRequired()
                         .HasColumnType("jsonb");
 
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
                     b.Property<string>("PositionsJson")
                         .IsRequired()
                         .HasColumnType("jsonb");
@@ -200,6 +227,11 @@ namespace Managing.Infrastructure.Databases.Migrations
                         .HasMaxLength(1000)
                         .HasColumnType("text");
 
+                    b.Property<decimal>("SharpeRatio")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("decimal(18,8)")
+                        .HasDefaultValue(0m);
+
                     b.Property<string>("SignalsJson")
                         .IsRequired()
                         .HasColumnType("jsonb");
@@ -210,6 +242,14 @@ namespace Managing.Infrastructure.Databases.Migrations
                     b.Property<string>("StatisticsJson")
                         .HasColumnType("jsonb");
 
+                    b.Property<string>("Ticker")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("Timeframe")
+                        .HasColumnType("integer");
+
                     b.Property<DateTime>("UpdatedAt")
                         .HasColumnType("timestamp with time zone");
 
@@ -232,8 +272,14 @@ namespace Managing.Infrastructure.Databases.Migrations
 
                     b.HasIndex("RequestId", "Score");
 
+                    b.HasIndex("UserId", "Name");
+
                     b.HasIndex("UserId", "Score");
 
+                    b.HasIndex("UserId", "Ticker");
+
+                    b.HasIndex("UserId", "Timeframe");
+
                     b.ToTable("Backtests");
                 });
 
diff --git a/src/Managing.Infrastructure.Database/PostgreSql/Entities/BacktestEntity.cs b/src/Managing.Infrastructure.Database/PostgreSql/Entities/BacktestEntity.cs
index 2b8499a2..c7a1125d 100644
--- a/src/Managing.Infrastructure.Database/PostgreSql/Entities/BacktestEntity.cs
+++ b/src/Managing.Infrastructure.Database/PostgreSql/Entities/BacktestEntity.cs
@@ -36,6 +36,28 @@ public class BacktestEntity
     [Column(TypeName = "jsonb")]
     public string ConfigJson { get; set; } = string.Empty;
 
+    // Denormalized bot/backtest name (e.g., "MyBundleTest #3") for sorting/filtering
+    [Required]
+    [MaxLength(255)]
+    public string Name { get; set; } = string.Empty;
+
+    // Denormalized ticker string for fast filtering/sorting
+    [Required]
+    [MaxLength(32)]
+    public string Ticker { get; set; } = string.Empty;
+
+    // Stored timeframe as enum numeric value for direct sorting/filtering
+    [Required]
+    public int Timeframe { get; set; }
+
+    // Comma-separated indicator types for filtering, e.g., "EMA_CROSS,MACD_CROSS"
+    [Column(TypeName = "text")]
+    public string IndicatorsCsv { get; set; } = string.Empty;
+
+    // Number of indicators used in the scenario for sorting/filtering
+    [Required]
+    public int IndicatorsCount { get; set; }
+
     [Required]
     [Column(TypeName = "jsonb")]
     public string PositionsJson { get; set; } = string.Empty;
@@ -50,6 +72,10 @@ public class BacktestEntity
     [Required]
     public DateTime EndDate { get; set; }
 
+    // Precomputed for filtering: EndDate - StartDate
+    [Required]
+    public TimeSpan Duration { get; set; }
+
     [Required]
     [Column(TypeName = "jsonb")]
     public string MoneyManagementJson { get; set; } = string.Empty;
@@ -63,6 +89,19 @@ public class BacktestEntity
     [Column(TypeName = "jsonb")]
     public string? StatisticsJson { get; set; }
 
+    // Extracted metrics for efficient querying/indexing
+    [Required]
+    [Column(TypeName = "decimal(18,8)")]
+    public decimal SharpeRatio { get; set; }
+
+    [Required]
+    [Column(TypeName = "decimal(18,8)")]
+    public decimal MaxDrawdown { get; set; }
+
+    // PostgreSQL maps TimeSpan to interval
+    [Required]
+    public TimeSpan MaxDrawdownRecoveryTime { get; set; }
+
     [Required]
     [Column(TypeName = "decimal(18,8)")]
     public decimal Fees { get; set; }
diff --git a/src/Managing.Infrastructure.Database/PostgreSql/ManagingDbContext.cs b/src/Managing.Infrastructure.Database/PostgreSql/ManagingDbContext.cs
index 8db0838e..5dbcdf18 100644
--- a/src/Managing.Infrastructure.Database/PostgreSql/ManagingDbContext.cs
+++ b/src/Managing.Infrastructure.Database/PostgreSql/ManagingDbContext.cs
@@ -156,10 +156,19 @@ public class ManagingDbContext : DbContext
             entity.Property(e => e.HodlPercentage).HasColumnType("decimal(18,8)");
             entity.Property(e => e.Fees).HasColumnType("decimal(18,8)");
             entity.Property(e => e.ConfigJson).HasColumnType("jsonb");
+            entity.Property(e => e.Name).IsRequired().HasMaxLength(255);
+            entity.Property(e => e.Ticker).HasMaxLength(32);
+            entity.Property(e => e.Timeframe).IsRequired();
+            entity.Property(e => e.IndicatorsCsv).HasColumnType("text");
+            entity.Property(e => e.IndicatorsCount).IsRequired();
             entity.Property(e => e.PositionsJson).HasColumnType("jsonb");
             entity.Property(e => e.SignalsJson).HasColumnType("jsonb");
             entity.Property(e => e.MoneyManagementJson).HasColumnType("jsonb");
             entity.Property(e => e.StatisticsJson).HasColumnType("jsonb");
+            entity.Property(e => e.SharpeRatio).HasColumnType("decimal(18,8)").HasDefaultValue(0m);
+            entity.Property(e => e.MaxDrawdown).HasColumnType("decimal(18,8)").HasDefaultValue(0m);
+            entity.Property(e => e.MaxDrawdownRecoveryTime).HasDefaultValue(TimeSpan.Zero);
+            entity.Property(e => e.Duration).HasDefaultValue(TimeSpan.Zero);
             entity.Property(e => e.ScoreMessage).HasMaxLength(1000);
             entity.Property(e => e.Metadata).HasColumnType("text");
 
@@ -177,7 +186,10 @@ public class ManagingDbContext : DbContext
 
             // Composite indexes for efficient pagination and filtering
             entity.HasIndex(e => new { e.UserId, e.Score });
+            entity.HasIndex(e => new { e.UserId, e.Name });
             entity.HasIndex(e => new { e.RequestId, e.Score });
+            entity.HasIndex(e => new { e.UserId, e.Ticker });
+            entity.HasIndex(e => new { e.UserId, e.Timeframe });
         });
 
         // Configure BundleBacktestRequest entity
diff --git a/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlBacktestRepository.cs b/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlBacktestRepository.cs
index 50db7e3a..26c23987 100644
--- a/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlBacktestRepository.cs
+++ b/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlBacktestRepository.cs
@@ -1,12 +1,14 @@
 using System.Diagnostics;
 using Exilion.TradingAtomics;
 using Managing.Application.Abstractions.Repositories;
+using Managing.Application.Abstractions.Shared;
 using Managing.Domain.Backtests;
 using Managing.Domain.Bots;
 using Managing.Domain.Users;
 using Managing.Infrastructure.Databases.PostgreSql.Entities;
 using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
+using static Managing.Common.Enums;
 
 namespace Managing.Infrastructure.Databases.PostgreSql;
 
@@ -377,8 +379,13 @@ public class PostgreSqlBacktestRepository : IBacktestRepository
         }
     }
 
-    public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(User user, int page,
-        int pageSize, string sortBy = "score", string sortOrder = "desc")
+    public (IEnumerable<LightBacktest> Backtests, int TotalCount) GetBacktestsByUserPaginated(
+        User user,
+        int page,
+        int pageSize,
+        BacktestSortableColumn sortBy = BacktestSortableColumn.Score,
+        string sortOrder = "desc",
+        BacktestsFilter? filter = null)
     {
         var stopwatch = Stopwatch.StartNew();
         
@@ -386,28 +393,83 @@ public class PostgreSqlBacktestRepository : IBacktestRepository
             .AsNoTracking()
             .Where(b => b.UserId == user.Id);
 
+        if (filter != null)
+        {
+            if (filter.ScoreMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.Score >= filter.ScoreMin.Value);
+            if (filter.ScoreMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.Score <= filter.ScoreMax.Value);
+            if (filter.WinrateMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.WinRate >= filter.WinrateMin.Value);
+            if (filter.WinrateMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.WinRate <= filter.WinrateMax.Value);
+            if (filter.MaxDrawdownMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.MaxDrawdown <= filter.MaxDrawdownMax.Value);
+
+            if (filter.Tickers != null && filter.Tickers.Any())
+            {
+                var tickerArray = filter.Tickers.ToArray();
+                baseQuery = baseQuery.Where(b => tickerArray.Contains(b.Ticker));
+            }
+
+            if (filter.Indicators != null && filter.Indicators.Any())
+            {
+                foreach (var ind in filter.Indicators)
+                {
+                    var token = "," + ind + ",";
+                    baseQuery = baseQuery.Where(b => ("," + b.IndicatorsCsv + ",").Contains(token));
+                }
+            }
+
+            if (filter.DurationMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.Duration >= filter.DurationMin.Value);
+            if (filter.DurationMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.Duration <= filter.DurationMax.Value);
+        }
+
         var afterQueryMs = stopwatch.ElapsedMilliseconds;
         var totalCount = baseQuery.Count();
         var afterCountMs = stopwatch.ElapsedMilliseconds;
 
         // Apply sorting
-        IQueryable<BacktestEntity> sortedQuery = sortBy.ToLower() switch
+        IQueryable<BacktestEntity> sortedQuery = sortBy switch
         {
-            "score" => sortOrder == "desc"
+            BacktestSortableColumn.Score => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.Score)
                 : baseQuery.OrderBy(b => b.Score),
-            "finalpnl" => sortOrder == "desc"
+            BacktestSortableColumn.FinalPnl => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.FinalPnl)
                 : baseQuery.OrderBy(b => b.FinalPnl),
-            "winrate" => sortOrder == "desc"
+            BacktestSortableColumn.WinRate => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.WinRate)
                 : baseQuery.OrderBy(b => b.WinRate),
-            "growthpercentage" => sortOrder == "desc"
+            BacktestSortableColumn.GrowthPercentage => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.GrowthPercentage)
                 : baseQuery.OrderBy(b => b.GrowthPercentage),
-            "hodlpercentage" => sortOrder == "desc"
+            BacktestSortableColumn.HodlPercentage => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.HodlPercentage)
                 : baseQuery.OrderBy(b => b.HodlPercentage),
+            BacktestSortableColumn.Duration => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Duration)
+                : baseQuery.OrderBy(b => b.Duration),
+            BacktestSortableColumn.Timeframe => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Timeframe)
+                : baseQuery.OrderBy(b => b.Timeframe),
+            BacktestSortableColumn.IndicatorsCount => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.IndicatorsCount)
+                : baseQuery.OrderBy(b => b.IndicatorsCount),
+            BacktestSortableColumn.MaxDrawdown => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.MaxDrawdown)
+                : baseQuery.OrderBy(b => b.MaxDrawdown),
+            BacktestSortableColumn.Fees => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Fees)
+                : baseQuery.OrderBy(b => b.Fees),
+            BacktestSortableColumn.SharpeRatio => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.SharpeRatio)
+                : baseQuery.OrderBy(b => b.SharpeRatio),
+            BacktestSortableColumn.Ticker => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Ticker)
+                : baseQuery.OrderBy(b => b.Ticker),
             _ => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.Score)
                 : baseQuery.OrderBy(b => b.Score)
@@ -427,21 +489,16 @@ public class PostgreSqlBacktestRepository : IBacktestRepository
         {
             Id = entity.Identifier,
             Config = JsonConvert.DeserializeObject<TradingBotConfig>(entity.ConfigJson),
+            Ticker = entity.Ticker,
             FinalPnl = entity.FinalPnl,
             WinRate = entity.WinRate,
             GrowthPercentage = entity.GrowthPercentage,
             HodlPercentage = entity.HodlPercentage,
             StartDate = entity.StartDate,
             EndDate = entity.EndDate,
-            MaxDrawdown = !string.IsNullOrEmpty(entity.StatisticsJson)
-                ? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.MaxDrawdown
-                : null,
+            MaxDrawdown = entity.MaxDrawdown,
             Fees = entity.Fees,
-            SharpeRatio = !string.IsNullOrEmpty(entity.StatisticsJson)
-                ? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.SharpeRatio != null
-                    ? (double?)JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson).SharpeRatio
-                    : null
-                : null,
+            SharpeRatio = (double?)entity.SharpeRatio,
             Score = entity.Score,
             ScoreMessage = entity.ScoreMessage ?? string.Empty
         });
@@ -450,36 +507,95 @@ public class PostgreSqlBacktestRepository : IBacktestRepository
     }
 
     public async Task<(IEnumerable<LightBacktest> Backtests, int TotalCount)> GetBacktestsByUserPaginatedAsync(
-        User user, int page, int pageSize, string sortBy = "score", string sortOrder = "desc")
+        User user,
+        int page,
+        int pageSize,
+        BacktestSortableColumn sortBy = BacktestSortableColumn.Score,
+        string sortOrder = "desc",
+        BacktestsFilter? filter = null)
     {
         var stopwatch = Stopwatch.StartNew();
         
         var baseQuery = _context.Backtests
             .AsNoTracking()
             .Where(b => b.UserId == user.Id);
+        if (filter != null)
+        {
+            if (filter.ScoreMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.Score >= filter.ScoreMin.Value);
+            if (filter.ScoreMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.Score <= filter.ScoreMax.Value);
+            if (filter.WinrateMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.WinRate >= filter.WinrateMin.Value);
+            if (filter.WinrateMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.WinRate <= filter.WinrateMax.Value);
+            if (filter.MaxDrawdownMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.MaxDrawdown <= filter.MaxDrawdownMax.Value);
+
+            if (filter.Tickers != null && filter.Tickers.Any())
+            {
+                var tickerArray = filter.Tickers.ToArray();
+                baseQuery = baseQuery.Where(b => tickerArray.Contains(b.Ticker));
+            }
+
+            if (filter.Indicators != null && filter.Indicators.Any())
+            {
+                foreach (var ind in filter.Indicators)
+                {
+                    var token = "," + ind + ",";
+                    baseQuery = baseQuery.Where(b => ("," + b.IndicatorsCsv + ",").Contains(token));
+                }
+            }
+
+            if (filter.DurationMin.HasValue)
+                baseQuery = baseQuery.Where(b => b.Duration >= filter.DurationMin.Value);
+            if (filter.DurationMax.HasValue)
+                baseQuery = baseQuery.Where(b => b.Duration <= filter.DurationMax.Value);
+        }
 
         var afterQueryMs = stopwatch.ElapsedMilliseconds;
         var totalCount = await baseQuery.CountAsync().ConfigureAwait(false);
         var afterCountMs = stopwatch.ElapsedMilliseconds;
 
         // Apply sorting
-        IQueryable<BacktestEntity> sortedQuery = sortBy.ToLower() switch
+        IQueryable<BacktestEntity> sortedQuery = sortBy switch
         {
-            "score" => sortOrder == "desc"
+            BacktestSortableColumn.Score => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.Score)
                 : baseQuery.OrderBy(b => b.Score),
-            "finalpnl" => sortOrder == "desc"
+            BacktestSortableColumn.FinalPnl => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.FinalPnl)
                 : baseQuery.OrderBy(b => b.FinalPnl),
-            "winrate" => sortOrder == "desc"
+            BacktestSortableColumn.WinRate => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.WinRate)
                 : baseQuery.OrderBy(b => b.WinRate),
-            "growthpercentage" => sortOrder == "desc"
+            BacktestSortableColumn.GrowthPercentage => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.GrowthPercentage)
                 : baseQuery.OrderBy(b => b.GrowthPercentage),
-            "hodlpercentage" => sortOrder == "desc"
+            BacktestSortableColumn.HodlPercentage => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.HodlPercentage)
                 : baseQuery.OrderBy(b => b.HodlPercentage),
+            BacktestSortableColumn.Duration => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Duration)
+                : baseQuery.OrderBy(b => b.Duration),
+            BacktestSortableColumn.Timeframe => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Timeframe)
+                : baseQuery.OrderBy(b => b.Timeframe),
+            BacktestSortableColumn.IndicatorsCount => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.IndicatorsCount)
+                : baseQuery.OrderBy(b => b.IndicatorsCount),
+            BacktestSortableColumn.MaxDrawdown => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.MaxDrawdown)
+                : baseQuery.OrderBy(b => b.MaxDrawdown),
+            BacktestSortableColumn.Fees => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Fees)
+                : baseQuery.OrderBy(b => b.Fees),
+            BacktestSortableColumn.SharpeRatio => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.SharpeRatio)
+                : baseQuery.OrderBy(b => b.SharpeRatio),
+            BacktestSortableColumn.Ticker => sortOrder == "desc"
+                ? baseQuery.OrderByDescending(b => b.Ticker)
+                : baseQuery.OrderBy(b => b.Ticker),
             _ => sortOrder == "desc"
                 ? baseQuery.OrderByDescending(b => b.Score)
                 : baseQuery.OrderBy(b => b.Score)
@@ -506,15 +622,9 @@ public class PostgreSqlBacktestRepository : IBacktestRepository
             HodlPercentage = entity.HodlPercentage,
             StartDate = entity.StartDate,
             EndDate = entity.EndDate,
-            MaxDrawdown = !string.IsNullOrEmpty(entity.StatisticsJson)
-                ? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.MaxDrawdown
-                : null,
+            MaxDrawdown = entity.MaxDrawdown,
             Fees = entity.Fees,
-            SharpeRatio = !string.IsNullOrEmpty(entity.StatisticsJson)
-                ? JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson)?.SharpeRatio != null
-                    ? (double?)JsonConvert.DeserializeObject<PerformanceMetrics>(entity.StatisticsJson).SharpeRatio
-                    : null
-                : null,
+            SharpeRatio = (double?)entity.SharpeRatio,
             Score = entity.Score,
             ScoreMessage = entity.ScoreMessage ?? string.Empty
         });
diff --git a/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlMappers.cs b/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlMappers.cs
index fa7ebec6..ea2ae5a5 100644
--- a/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlMappers.cs
+++ b/src/Managing.Infrastructure.Database/PostgreSql/PostgreSqlMappers.cs
@@ -332,13 +332,22 @@ public static class PostgreSqlMappers
             GrowthPercentage = backtest.GrowthPercentage,
             HodlPercentage = backtest.HodlPercentage,
             ConfigJson = JsonConvert.SerializeObject(backtest.Config),
+            Name = backtest.Config?.Name ?? string.Empty,
+            Ticker = backtest.Config?.Ticker.ToString() ?? string.Empty,
+            Timeframe = (int)backtest.Config.Timeframe,
+            IndicatorsCsv = string.Join(',', backtest.Config.Scenario.Indicators.Select(i => i.Type.ToString())),
+            IndicatorsCount = backtest.Config.Scenario.Indicators.Count,
             PositionsJson = JsonConvert.SerializeObject(backtest.Positions.Values.ToList()),
             SignalsJson = JsonConvert.SerializeObject(backtest.Signals.Values.ToList()),
             StartDate = backtest.StartDate,
             EndDate = backtest.EndDate,
+            Duration = backtest.EndDate - backtest.StartDate,
             MoneyManagementJson = JsonConvert.SerializeObject(backtest.Config?.MoneyManagement),
             UserId = backtest.User?.Id ?? 0,
             StatisticsJson = backtest.Statistics != null ? JsonConvert.SerializeObject(backtest.Statistics) : null,
+            SharpeRatio = backtest.Statistics?.SharpeRatio ?? 0m,
+            MaxDrawdown = backtest.Statistics?.MaxDrawdown ?? 0m,
+            MaxDrawdownRecoveryTime = backtest.Statistics?.MaxDrawdownRecoveryTime ?? TimeSpan.Zero,
             Fees = backtest.Fees,
             Score = backtest.Score,
             ScoreMessage = backtest.ScoreMessage ?? string.Empty,
@@ -976,4 +985,13 @@ public static class PostgreSqlMappers
     }
 
     #endregion
+
+    private static int? ExtractBundleIndex(string name)
+    {
+        if (string.IsNullOrWhiteSpace(name)) return null;
+        var hashIndex = name.LastIndexOf('#');
+        if (hashIndex < 0 || hashIndex + 1 >= name.Length) return null;
+        var numberPart = name.Substring(hashIndex + 1).Trim();
+        return int.TryParse(numberPart, out var n) ? n : (int?)null;
+    }
 }
\ No newline at end of file
diff --git a/src/Managing.WebApp/package.json b/src/Managing.WebApp/package.json
index 9ac3ed36..f8c4a0e7 100644
--- a/src/Managing.WebApp/package.json
+++ b/src/Managing.WebApp/package.json
@@ -22,6 +22,7 @@
     "@privy-io/wagmi": "^1.0.3",
     "@tailwindcss/typography": "^0.5.0",
     "@tanstack/react-query": "^5.67.1",
+    "@tanstack/react-table": "^8.21.3",
     "@wagmi/chains": "^0.2.9",
     "@wagmi/connectors": "^5.7.3",
     "@wagmi/core": "^2.17.0",
diff --git a/src/Managing.WebApp/src/components/organism/Backtest/backtestTable.tsx b/src/Managing.WebApp/src/components/organism/Backtest/backtestTable.tsx
index bb3103bc..217936d1 100644
--- a/src/Managing.WebApp/src/components/organism/Backtest/backtestTable.tsx
+++ b/src/Managing.WebApp/src/components/organism/Backtest/backtestTable.tsx
@@ -5,7 +5,7 @@ import {useExpanded, useFilters, usePagination, useSortBy, useTable,} from 'reac
 import useApiUrlStore from '../../../app/store/apiStore'
 import useBacktestStore from '../../../app/store/backtestStore'
 import type {Backtest, LightBacktestResponse} from '../../../generated/ManagingApi'
-import {BacktestClient} from '../../../generated/ManagingApi'
+import {BacktestClient, BacktestSortableColumn, IndicatorType} from '../../../generated/ManagingApi'
 import {ConfigDisplayModal, IndicatorsDisplay, SelectColumnFilter} from '../../mollecules'
 import {UnifiedTradingModal} from '../index'
 import Toast from '../../mollecules/Toast/Toast'
@@ -72,15 +72,15 @@ const ServerSortableTable = ({
                                     </p>
                                     <span className="relative">
                                         {(() => {
-                                            // Map backend field names to column IDs for comparison
-                                            const backendToColumnMapping: { [key: string]: string } = {
-                                                'score': 'score',
-                                                'finalpnl': 'finalPnl',
-                                                'winrate': 'winRate',
-                                                'growthpercentage': 'growthPercentage',
-                                                'hodlpercentage': 'hodlPercentage',
+                                            // Map enum sortable fields to table column ids
+                                            const enumToColumnMapping: { [key in BacktestSortableColumn]?: string } = {
+                                                [BacktestSortableColumn.Score]: 'score',
+                                                [BacktestSortableColumn.FinalPnl]: 'finalPnl',
+                                                [BacktestSortableColumn.WinRate]: 'winRate',
+                                                [BacktestSortableColumn.GrowthPercentage]: 'growthPercentage',
+                                                [BacktestSortableColumn.HodlPercentage]: 'hodlPercentage',
                                             };
-                                            const columnId = backendToColumnMapping[currentSort?.sortBy || ''] || currentSort?.sortBy;
+                                            const columnId = enumToColumnMapping[currentSort?.sortBy as BacktestSortableColumn] || currentSort?.sortBy;
                                             
                                             return currentSort?.sortBy && columnId === column.id ? (
                                                 currentSort.sortOrder === 'desc' ? (
@@ -133,14 +133,36 @@ interface BacktestTableProps {
     list: LightBacktestResponse[] | undefined
     isFetching?: boolean
     displaySummary?: boolean
-    onSortChange?: (sortBy: string, sortOrder: 'asc' | 'desc') => void
-    currentSort?: { sortBy: string; sortOrder: 'asc' | 'desc' }
+    onSortChange?: (sortBy: BacktestSortableColumn, sortOrder: 'asc' | 'desc') => void
+    currentSort?: { sortBy: BacktestSortableColumn; sortOrder: 'asc' | 'desc' }
     onBacktestDeleted?: () => void // Callback when a backtest is deleted
+    onFiltersChange?: (filters: {
+        scoreMin?: number | null
+        scoreMax?: number | null
+        winrateMin?: number | null
+        winrateMax?: number | null
+        maxDrawdownMax?: number | null
+        tickers?: string[] | null
+        indicators?: string[] | null
+        durationMinDays?: number | null
+        durationMaxDays?: number | null
+    }) => void
+    filters?: {
+        scoreMin?: number | null
+        scoreMax?: number | null
+        winrateMin?: number | null
+        winrateMax?: number | null
+        maxDrawdownMax?: number | null
+        tickers?: string[] | null
+        indicators?: string[] | null
+        durationMinDays?: number | null
+        durationMaxDays?: number | null
+    }
 }
 
 
 
-const BacktestTable: React.FC<BacktestTableProps> = ({list, isFetching, onSortChange, currentSort, onBacktestDeleted}) => {
+const BacktestTable: React.FC<BacktestTableProps> = ({list, isFetching, onSortChange, currentSort, onBacktestDeleted, onFiltersChange, filters}) => {
     const [rows, setRows] = useState<LightBacktestResponse[]>([])
     const {apiUrl} = useApiUrlStore()
     const {removeBacktest} = useBacktestStore()
@@ -157,20 +179,75 @@ const BacktestTable: React.FC<BacktestTableProps> = ({list, isFetching, onSortCh
     const [showConfigDisplayModal, setShowConfigDisplayModal] = useState(false)
     const [selectedBacktestForConfigView, setSelectedBacktestForConfigView] = useState<Backtest | null>(null)
 
+    // Filters sidebar state
+    const [isFilterOpen, setIsFilterOpen] = useState(false)
+    const [scoreMin, setScoreMin] = useState<number>(0)
+    const [scoreMax, setScoreMax] = useState<number>(100)
+    const [winMin, setWinMin] = useState<number>(0)
+    const [winMax, setWinMax] = useState<number>(100)
+    const [maxDrawdownMax, setMaxDrawdownMax] = useState<number | ''>('')
+    const [tickersInput, setTickersInput] = useState<string>('')
+    const [selectedIndicators, setSelectedIndicators] = useState<string[]>([])
+    const [durationMinDays, setDurationMinDays] = useState<number | null>(null)
+    const [durationMaxDays, setDurationMaxDays] = useState<number | null>(null)
+
+    const applyFilters = () => {
+        if (!onFiltersChange) return
+        onFiltersChange({
+            scoreMin,
+            scoreMax,
+            winrateMin: winMin,
+            winrateMax: winMax,
+            maxDrawdownMax: maxDrawdownMax === '' ? null : Number(maxDrawdownMax),
+            tickers: tickersInput ? tickersInput.split(',').map(s => s.trim()).filter(Boolean) : null,
+            indicators: selectedIndicators.length ? selectedIndicators : null,
+            durationMinDays,
+            durationMaxDays,
+        })
+        setIsFilterOpen(false)
+    }
+
+    const clearDuration = () => {
+        setDurationMinDays(null)
+        setDurationMaxDays(null)
+    }
+
+    const toggleIndicator = (name: string) => {
+        setSelectedIndicators(prev => prev.includes(name)
+            ? prev.filter(i => i !== name)
+            : [...prev, name])
+    }
+
+    const clearIndicators = () => setSelectedIndicators([])
+
+    // Sync incoming filters prop to local sidebar state
+    useEffect(() => {
+        if (!filters) return
+        if (typeof filters.scoreMin === 'number') setScoreMin(filters.scoreMin)
+        if (typeof filters.scoreMax === 'number') setScoreMax(filters.scoreMax)
+        if (typeof filters.winrateMin === 'number') setWinMin(filters.winrateMin)
+        if (typeof filters.winrateMax === 'number') setWinMax(filters.winrateMax)
+        if (typeof filters.maxDrawdownMax === 'number') setMaxDrawdownMax(filters.maxDrawdownMax)
+        setTickersInput(filters.tickers && filters.tickers.length ? filters.tickers.join(',') : '')
+        setSelectedIndicators(filters.indicators ? [...filters.indicators] : [])
+        setDurationMinDays(filters.durationMinDays ?? null)
+        setDurationMaxDays(filters.durationMaxDays ?? null)
+    }, [filters])
+
     // Handle sort change
     const handleSortChange = (columnId: string, sortOrder: 'asc' | 'desc') => {
         if (!onSortChange) return;
         
-        // Map column IDs to backend field names
-        const sortByMapping: { [key: string]: string } = {
-            'score': 'score',
-            'finalPnl': 'finalpnl',
-            'winRate': 'winrate',
-            'growthPercentage': 'growthpercentage',
-            'hodlPercentage': 'hodlpercentage',
+        // Map column IDs to BacktestSortableColumn enum
+        const sortByMapping: { [key: string]: BacktestSortableColumn } = {
+            'score': BacktestSortableColumn.Score,
+            'finalPnl': BacktestSortableColumn.FinalPnl,
+            'winRate': BacktestSortableColumn.WinRate,
+            'growthPercentage': BacktestSortableColumn.GrowthPercentage,
+            'hodlPercentage': BacktestSortableColumn.HodlPercentage,
         };
         
-        const backendSortBy = sortByMapping[columnId] || 'score';
+        const backendSortBy = sortByMapping[columnId] || BacktestSortableColumn.Score;
         onSortChange(backendSortBy, sortOrder);
     };
 
@@ -486,6 +563,11 @@ const BacktestTable: React.FC<BacktestTableProps> = ({list, isFetching, onSortCh
                 </div>
             ) : (
                 <>
+                    {/* Filters toggle button */}
+                    <div className="flex w-full justify-end">
+                        <button className="btn btn-sm btn-outline" onClick={() => setIsFilterOpen(true)}>Filters</button>
+                    </div>
+
                     <ServerSortableTable
                         columns={columns}
                         data={rows}
@@ -498,6 +580,100 @@ const BacktestTable: React.FC<BacktestTableProps> = ({list, isFetching, onSortCh
                         currentSort={currentSort}
                     />
 
+                    {/* Right sidebar filter panel */}
+                    {isFilterOpen && (
+                        <>
+                            <div className="fixed inset-0 bg-black/30" onClick={() => setIsFilterOpen(false)}></div>
+                            <div className="fixed right-0 top-0 h-full w-96 bg-base-200 shadow-xl p-4 overflow-y-auto">
+                                <div className="flex items-center justify-between mb-4">
+                                    <h3 className="text-lg font-semibold">Filters</h3>
+                                    <button className="btn btn-ghost btn-sm" onClick={() => setIsFilterOpen(false)}>✕</button>
+                                </div>
+
+                                {/* Score range */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium">Score between</div>
+                                    <div className="flex gap-2 items-center">
+                                        <input type="number" min={0} max={100} className="input input-bordered input-sm w-20" value={scoreMin} onChange={e => setScoreMin(Math.min(100, Math.max(0, Number(e.target.value))))} />
+                                        <span>to</span>
+                                        <input type="number" min={0} max={100} className="input input-bordered input-sm w-20" value={scoreMax} onChange={e => setScoreMax(Math.min(100, Math.max(0, Number(e.target.value))))} />
+                                    </div>
+                                </div>
+
+                                {/* Tickers */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium">Tickers</div>
+                                    <input
+                                        type="text"
+                                        placeholder="e.g. BTC, ETH, SOL"
+                                        className="input input-bordered input-sm w-full"
+                                        value={tickersInput}
+                                        onChange={e => setTickersInput(e.target.value)}
+                                    />
+                                </div>
+
+                                {/* Max Drawdown */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium">Max Drawdown (max)</div>
+                                    <input type="number" className="input input-bordered input-sm w-full" placeholder="Put the max amount" value={maxDrawdownMax} onChange={e => {
+                                        const v = e.target.value
+                                        if (v === '') setMaxDrawdownMax('')
+                                        else setMaxDrawdownMax(Number(v))
+                                    }} />
+                                </div>
+
+                                {/* Indicators (enum selection) */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium flex items-center justify-between">
+                                        <span>Indicators</span>
+                                        {selectedIndicators.length > 0 && (
+                                            <button className="btn btn-ghost btn-xs" onClick={clearIndicators}>Clear</button>
+                                        )}
+                                    </div>
+                                    <div className="flex flex-wrap gap-2">
+                                        {Object.values(IndicatorType).map((ind) => (
+                                            <button
+                                                key={ind as string}
+                                                className={`btn btn-xs ${selectedIndicators.includes(ind as string) ? 'btn-primary' : 'btn-outline'}`}
+                                                onClick={() => toggleIndicator(ind as string)}
+                                            >
+                                                {ind as string}
+                                            </button>
+                                        ))}
+                                    </div>
+                                </div>
+
+                                {/* Winrate */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium">Winrate between</div>
+                                    <div className="flex gap-2 items-center">
+                                        <input type="number" min={0} max={100} className="input input-bordered input-sm w-20" value={winMin} onChange={e => setWinMin(Math.min(100, Math.max(0, Number(e.target.value))))} />
+                                        <span>to</span>
+                                        <input type="number" min={0} max={100} className="input input-bordered input-sm w-20" value={winMax} onChange={e => setWinMax(Math.min(100, Math.max(0, Number(e.target.value))))} />
+                                    </div>
+                                </div>
+
+                                {/* Duration */}
+                                <div className="mb-6">
+                                    <div className="mb-2 font-medium">Duration</div>
+                                    <div className="flex flex-wrap gap-2">
+                                        <button className={`btn btn-xs ${durationMaxDays === 30 && durationMinDays === 0 ? 'btn-primary' : 'btn-outline'}`} onClick={() => { setDurationMinDays(0); setDurationMaxDays(30); }}>Up to 1 month</button>
+                                        <button className={`btn btn-xs ${durationMinDays === 30 && durationMaxDays === 60 ? 'btn-primary' : 'btn-outline'}`} onClick={() => { setDurationMinDays(30); setDurationMaxDays(60); }}>1-2 months</button>
+                                        <button className={`btn btn-xs ${durationMinDays === 90 && durationMaxDays === 150 ? 'btn-primary' : 'btn-outline'}`} onClick={() => { setDurationMinDays(90); setDurationMaxDays(150); }}>3-5 months</button>
+                                        <button className={`btn btn-xs ${durationMinDays === 180 && durationMaxDays === 330 ? 'btn-primary' : 'btn-outline'}`} onClick={() => { setDurationMinDays(180); setDurationMaxDays(330); }}>6-11 months</button>
+                                        <button className={`btn btn-xs ${durationMinDays === 365 && durationMaxDays === null ? 'btn-primary' : 'btn-outline'}`} onClick={() => { setDurationMinDays(365); setDurationMaxDays(null); }}>1 year or more</button>
+                                        <button className="btn btn-xs btn-ghost" onClick={clearDuration}>Clear</button>
+                                    </div>
+                                </div>
+
+                                <div className="flex gap-2 justify-end">
+                                    <button className="btn btn-ghost btn-sm" onClick={() => setIsFilterOpen(false)}>Cancel</button>
+                                    <button className="btn btn-primary btn-sm" onClick={applyFilters}>Apply</button>
+                                </div>
+                            </div>
+                        </>
+                    )}
+
                     {/* Bot Configuration Modal */}
                     {selectedBacktest && (
                         <UnifiedTradingModal
diff --git a/src/Managing.WebApp/src/generated/ManagingApi.ts b/src/Managing.WebApp/src/generated/ManagingApi.ts
index 24266fa8..3c176abb 100644
--- a/src/Managing.WebApp/src/generated/ManagingApi.ts
+++ b/src/Managing.WebApp/src/generated/ManagingApi.ts
@@ -665,7 +665,7 @@ export class BacktestClient extends AuthorizedApiBase {
         return Promise.resolve<PaginatedBacktestsResponse>(null as any);
     }
 
-    backtest_GetBacktestsPaginated(page: number | undefined, pageSize: number | undefined, sortBy: string | null | undefined, sortOrder: string | null | undefined): Promise<PaginatedBacktestsResponse> {
+    backtest_GetBacktestsPaginated(page: number | undefined, pageSize: number | undefined, sortBy: BacktestSortableColumn | undefined, sortOrder: string | null | undefined, scoreMin: number | null | undefined, scoreMax: number | null | undefined, winrateMin: number | null | undefined, winrateMax: number | null | undefined, maxDrawdownMax: number | null | undefined, tickers: string | null | undefined, indicators: string | null | undefined, durationMinDays: number | null | undefined, durationMaxDays: number | null | undefined): Promise<PaginatedBacktestsResponse> {
         let url_ = this.baseUrl + "/Backtest/Paginated?";
         if (page === null)
             throw new Error("The parameter 'page' cannot be null.");
@@ -675,10 +675,30 @@ export class BacktestClient extends AuthorizedApiBase {
             throw new Error("The parameter 'pageSize' cannot be null.");
         else if (pageSize !== undefined)
             url_ += "pageSize=" + encodeURIComponent("" + pageSize) + "&";
-        if (sortBy !== undefined && sortBy !== null)
+        if (sortBy === null)
+            throw new Error("The parameter 'sortBy' cannot be null.");
+        else if (sortBy !== undefined)
             url_ += "sortBy=" + encodeURIComponent("" + sortBy) + "&";
         if (sortOrder !== undefined && sortOrder !== null)
             url_ += "sortOrder=" + encodeURIComponent("" + sortOrder) + "&";
+        if (scoreMin !== undefined && scoreMin !== null)
+            url_ += "scoreMin=" + encodeURIComponent("" + scoreMin) + "&";
+        if (scoreMax !== undefined && scoreMax !== null)
+            url_ += "scoreMax=" + encodeURIComponent("" + scoreMax) + "&";
+        if (winrateMin !== undefined && winrateMin !== null)
+            url_ += "winrateMin=" + encodeURIComponent("" + winrateMin) + "&";
+        if (winrateMax !== undefined && winrateMax !== null)
+            url_ += "winrateMax=" + encodeURIComponent("" + winrateMax) + "&";
+        if (maxDrawdownMax !== undefined && maxDrawdownMax !== null)
+            url_ += "maxDrawdownMax=" + encodeURIComponent("" + maxDrawdownMax) + "&";
+        if (tickers !== undefined && tickers !== null)
+            url_ += "tickers=" + encodeURIComponent("" + tickers) + "&";
+        if (indicators !== undefined && indicators !== null)
+            url_ += "indicators=" + encodeURIComponent("" + indicators) + "&";
+        if (durationMinDays !== undefined && durationMinDays !== null)
+            url_ += "durationMinDays=" + encodeURIComponent("" + durationMinDays) + "&";
+        if (durationMaxDays !== undefined && durationMaxDays !== null)
+            url_ += "durationMaxDays=" + encodeURIComponent("" + durationMaxDays) + "&";
         url_ = url_.replace(/[?&]$/, "");
 
         let options_: RequestInit = {
@@ -4275,6 +4295,21 @@ export interface LightBacktestResponse {
     scoreMessage: string;
 }
 
+export enum BacktestSortableColumn {
+    Score = "Score",
+    FinalPnl = "FinalPnl",
+    WinRate = "WinRate",
+    GrowthPercentage = "GrowthPercentage",
+    HodlPercentage = "HodlPercentage",
+    Duration = "Duration",
+    Timeframe = "Timeframe",
+    IndicatorsCount = "IndicatorsCount",
+    MaxDrawdown = "MaxDrawdown",
+    Fees = "Fees",
+    SharpeRatio = "SharpeRatio",
+    Ticker = "Ticker",
+}
+
 export interface LightBacktest {
     id?: string | null;
     config?: TradingBotConfig | null;
@@ -4290,6 +4325,7 @@ export interface LightBacktest {
     score?: number;
     scoreMessage?: string | null;
     metadata?: any | null;
+    ticker?: string | null;
 }
 
 export interface RunBacktestRequest {
@@ -4305,7 +4341,7 @@ export interface RunBacktestRequest {
 }
 
 export interface TradingBotConfigRequest {
-    accountName: string;
+    accountName?: string | null;
     ticker: Ticker;
     timeframe: Timeframe;
     isForWatchingOnly: boolean;
diff --git a/src/Managing.WebApp/src/generated/ManagingApiTypes.ts b/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
index 4ddabba9..14af56de 100644
--- a/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
+++ b/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
@@ -532,6 +532,21 @@ export interface LightBacktestResponse {
     scoreMessage: string;
 }
 
+export enum BacktestSortableColumn {
+    Score = "Score",
+    FinalPnl = "FinalPnl",
+    WinRate = "WinRate",
+    GrowthPercentage = "GrowthPercentage",
+    HodlPercentage = "HodlPercentage",
+    Duration = "Duration",
+    Timeframe = "Timeframe",
+    IndicatorsCount = "IndicatorsCount",
+    MaxDrawdown = "MaxDrawdown",
+    Fees = "Fees",
+    SharpeRatio = "SharpeRatio",
+    Ticker = "Ticker",
+}
+
 export interface LightBacktest {
     id?: string | null;
     config?: TradingBotConfig | null;
@@ -547,6 +562,7 @@ export interface LightBacktest {
     score?: number;
     scoreMessage?: string | null;
     metadata?: any | null;
+    ticker?: string | null;
 }
 
 export interface RunBacktestRequest {
@@ -562,7 +578,7 @@ export interface RunBacktestRequest {
 }
 
 export interface TradingBotConfigRequest {
-    accountName: string;
+    accountName?: string | null;
     ticker: Ticker;
     timeframe: Timeframe;
     isForWatchingOnly: boolean;
@@ -656,7 +672,6 @@ export interface RunBundleBacktestRequest {
 }
 
 export interface BundleBacktestUniversalConfig {
-    accountName: string;
     timeframe: Timeframe;
     isForWatchingOnly: boolean;
     botTradingBalance: number;
diff --git a/src/Managing.WebApp/src/pages/backtestPage/backtestScanner.tsx b/src/Managing.WebApp/src/pages/backtestPage/backtestScanner.tsx
index ad8d1e20..e29f4b70 100644
--- a/src/Managing.WebApp/src/pages/backtestPage/backtestScanner.tsx
+++ b/src/Managing.WebApp/src/pages/backtestPage/backtestScanner.tsx
@@ -8,7 +8,7 @@ import {Loader, Slider} from '../../components/atoms'
 import {Modal, Toast} from '../../components/mollecules'
 import {BacktestTable, UnifiedTradingModal} from '../../components/organism'
 import type {LightBacktestResponse} from '../../generated/ManagingApi'
-import {BacktestClient} from '../../generated/ManagingApi'
+import {BacktestClient, BacktestSortableColumn} from '../../generated/ManagingApi'
 
 const PAGE_SIZE = 50
 
@@ -21,11 +21,24 @@ const BacktestScanner: React.FC = () => {
     score: 50
   })
   const [currentPage, setCurrentPage] = useState(1)
-  const [currentSort, setCurrentSort] = useState<{ sortBy: string; sortOrder: 'asc' | 'desc' }>({
-    sortBy: 'score',
+  const [currentSort, setCurrentSort] = useState<{ sortBy: BacktestSortableColumn; sortOrder: 'asc' | 'desc' }>({
+    sortBy: BacktestSortableColumn.Score,
     sortOrder: 'desc'
   })
 
+  // Filters state coming from BacktestTable sidebar
+  const [filters, setFilters] = useState<{
+    scoreMin?: number | null
+    scoreMax?: number | null
+    winrateMin?: number | null
+    winrateMax?: number | null
+    maxDrawdownMax?: number | null
+    tickers?: string[] | null
+    indicators?: string[] | null
+    durationMinDays?: number | null
+    durationMaxDays?: number | null
+  }>({})
+
   const { apiUrl } = useApiUrlStore()
   const queryClient = useQueryClient()
   const backtestClient = new BacktestClient({}, apiUrl)
@@ -37,13 +50,22 @@ const BacktestScanner: React.FC = () => {
     error,
     refetch
   } = useQuery({
-    queryKey: ['backtests', currentPage, currentSort.sortBy, currentSort.sortOrder],
+    queryKey: ['backtests', currentPage, currentSort.sortBy, currentSort.sortOrder, filters],
     queryFn: async () => {
       const response = await backtestClient.backtest_GetBacktestsPaginated(
-        currentPage, 
-        PAGE_SIZE, 
-        currentSort.sortBy, 
-        currentSort.sortOrder
+        currentPage,
+        PAGE_SIZE,
+        currentSort.sortBy,
+        currentSort.sortOrder,
+        filters.scoreMin ?? null,
+        filters.scoreMax ?? null,
+        filters.winrateMin ?? null,
+        filters.winrateMax ?? null,
+        filters.maxDrawdownMax ?? null,
+        (filters.tickers && filters.tickers.length ? filters.tickers.join(',') : null),
+        (filters.indicators && filters.indicators.length ? filters.indicators.join(',') : null),
+        filters.durationMinDays ?? null,
+        filters.durationMaxDays ?? null,
       )
       return {
         backtests: (response.backtests as LightBacktestResponse[]) || [],
@@ -176,11 +198,27 @@ const BacktestScanner: React.FC = () => {
   }
 
   // Sorting handler
-  const handleSortChange = (sortBy: string, sortOrder: 'asc' | 'desc') => {
+  const handleSortChange = (sortBy: BacktestSortableColumn, sortOrder: 'asc' | 'desc') => {
     setCurrentSort({ sortBy, sortOrder })
     setCurrentPage(1)
   }
 
+  // Filters handler from BacktestTable
+  const handleFiltersChange = (newFilters: {
+    scoreMin?: number | null
+    scoreMax?: number | null
+    winrateMin?: number | null
+    winrateMax?: number | null
+    maxDrawdownMax?: number | null
+    tickers?: string[] | null
+    indicators?: string[] | null
+    durationMinDays?: number | null
+    durationMaxDays?: number | null
+  }) => {
+    setFilters(newFilters)
+    setCurrentPage(1)
+  }
+
   // Pagination handler
   const handlePageChange = (newPage: number) => {
     if (newPage < 1 || (totalPages && newPage > totalPages)) return
@@ -207,11 +245,56 @@ const BacktestScanner: React.FC = () => {
         </button>
       </div>
 
+      {/* Selected filters summary */}
+      <div className="mt-2 mb-2">
+        {(
+          (filters.scoreMin !== undefined && filters.scoreMin !== null) ||
+          (filters.scoreMax !== undefined && filters.scoreMax !== null) ||
+          (filters.winrateMin !== undefined && filters.winrateMin !== null) ||
+          (filters.winrateMax !== undefined && filters.winrateMax !== null) ||
+          (filters.maxDrawdownMax !== undefined && filters.maxDrawdownMax !== null) ||
+          (filters.tickers && filters.tickers.length) ||
+          (filters.indicators && filters.indicators.length) ||
+          (filters.durationMinDays !== undefined && filters.durationMinDays !== null) ||
+          (filters.durationMaxDays !== undefined && filters.durationMaxDays !== null)
+        ) ? (
+          <div className="flex flex-wrap gap-2 items-center">
+            <span className="text-sm opacity-70 mr-1">Active filters:</span>
+            {filters.scoreMin !== undefined && filters.scoreMin !== null && (
+              <div className="badge badge-outline">Score ≥ {filters.scoreMin}</div>
+            )}
+            {filters.scoreMax !== undefined && filters.scoreMax !== null && (
+              <div className="badge badge-outline">Score ≤ {filters.scoreMax}</div>
+            )}
+            {filters.winrateMin !== undefined && filters.winrateMin !== null && (
+              <div className="badge badge-outline">Winrate ≥ {filters.winrateMin}%</div>
+            )}
+            {filters.winrateMax !== undefined && filters.winrateMax !== null && (
+              <div className="badge badge-outline">Winrate ≤ {filters.winrateMax}%</div>
+            )}
+            {filters.maxDrawdownMax !== undefined && filters.maxDrawdownMax !== null && (
+              <div className="badge badge-outline">Max DD ≤ {filters.maxDrawdownMax}</div>
+            )}
+            {filters.tickers && filters.tickers.length > 0 && (
+              <div className="badge badge-outline">Tickers: {filters.tickers.join(', ')}</div>
+            )}
+            {filters.indicators && filters.indicators.length > 0 && (
+              <div className="badge badge-outline">Indicators: {filters.indicators.join(', ')}</div>
+            )}
+            {(filters.durationMinDays !== undefined && filters.durationMinDays !== null) || (filters.durationMaxDays !== undefined && filters.durationMaxDays !== null) ? (
+              <div className="badge badge-outline">Duration: {filters.durationMinDays ?? 0}–{filters.durationMaxDays ?? '∞'} days</div>
+            ) : null}
+          </div>
+        ) : null}
+      </div>
+
       <BacktestTable
         list={backtests as LightBacktestResponse[]} // Cast to any for backward compatibility
         isFetching={isLoading}
         onSortChange={handleSortChange}
         currentSort={currentSort}
+        filters={filters}
+        onFiltersChange={handleFiltersChange}
         onBacktestDeleted={() => {
           // Invalidate backtest queries when a backtest is deleted
           queryClient.invalidateQueries({ queryKey: ['backtests'] })