diff --git a/src/Managing.Application/ManageBot/BotService.cs b/src/Managing.Application/ManageBot/BotService.cs
index d6591dc..1410eaf 100644
--- a/src/Managing.Application/ManageBot/BotService.cs
+++ b/src/Managing.Application/ManageBot/BotService.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using Managing.Application.Abstractions;
 using Managing.Application.Abstractions.Services;
 using Managing.Application.Bots;
@@ -14,20 +15,20 @@ namespace Managing.Application.ManageBot
     public class BotService : IBotService
     {
         private readonly IBotRepository _botRepository;
-        private readonly ITaskCache _taskCache;
         private readonly IExchangeService _exchangeService;
         private readonly IMessengerService _messengerService;
         private readonly IAccountService _accountService;
         private readonly ILogger<TradingBot> _tradingBotLogger;
         private readonly ITradingService _tradingService;
 
+        private ConcurrentDictionary<string, BotTaskWrapper> _botTasks =
+            new ConcurrentDictionary<string, BotTaskWrapper>();
 
-        public BotService(IBotRepository botRepository, ITaskCache taskCache, IExchangeService exchangeService,
+        public BotService(IBotRepository botRepository, IExchangeService exchangeService,
             IMessengerService messengerService, IAccountService accountService, ILogger<TradingBot> tradingBotLogger,
             ITradingService tradingService)
         {
             _botRepository = botRepository;
-            _taskCache = taskCache;
             _exchangeService = exchangeService;
             _messengerService = messengerService;
             _accountService = accountService;
@@ -66,20 +67,40 @@ namespace Managing.Application.ManageBot
             _botRepository.InsertBotAsync(botBackup);
         }
 
+        public class BotTaskWrapper
+        {
+            public Task Task { get; private set; }
+            public Type BotType { get; private set; }
+            public object BotInstance { get; private set; } // Add this line
+
+            public BotTaskWrapper(Task task, Type botType, object botInstance) // Update constructor
+            {
+                Task = task;
+                BotType = botType;
+                BotInstance = botInstance; // Set the bot instance
+            }
+        }
+
         public void AddSimpleBotToCache(IBot bot)
         {
-            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
+            var botTask =
+                new BotTaskWrapper(Task.Run(() => bot.Start()), bot.GetType(), bot); // Pass bot as the instance
+            _botTasks.AddOrUpdate(bot.GetName(), botTask, (key, existingVal) => botTask);
         }
 
         public void AddTradingBotToCache(ITradingBot bot)
         {
-            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
+            var botTask = new BotTaskWrapper(Task.Run(() => bot.Start()), bot.GetType(), bot);
+            _botTasks.AddOrUpdate(bot.GetName(), botTask, (key, existingVal) => botTask);
         }
 
         public List<ITradingBot> GetActiveBots()
         {
-            var cachedTask = _taskCache.GetCache<AsyncLazy<ITradingBot>>();
-            return cachedTask.Select(item => item.Value.Result).ToList();
+            return _botTasks.Values
+                .Where(wrapper => typeof(ITradingBot).IsAssignableFrom(wrapper.BotType))
+                .Select(wrapper => wrapper.BotInstance as ITradingBot)
+                .Where(bot => bot != null)
+                .ToList();
         }
 
         public IEnumerable<BotBackup> GetSavedBots()
@@ -89,46 +110,47 @@ namespace Managing.Application.ManageBot
 
         public void StartBotFromBackup(BotBackup backupBot)
         {
+            object bot = null;
+            Task botTask = null;
+
             switch (backupBot.BotType)
             {
                 case Enums.BotType.SimpleBot:
-                    Func<Task<IBot>> simpleBot = () =>
-                        Task.FromResult(CreateSimpleBot(backupBot.Name, null));
-                    var bot1 = _taskCache.AddOrGetExisting(backupBot.Name, simpleBot).Result;
-                    bot1.LoadBackup(backupBot);
-                    bot1.Start();
+                    bot = CreateSimpleBot(backupBot.Name,
+                        null); // Assuming null is an acceptable parameter for workflow
+                    botTask = Task.Run(() => ((IBot)bot).Start());
                     break;
                 case Enums.BotType.ScalpingBot:
-                    var data = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
-                    Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(CreateScalpingBot(
-                        data.AccountName,
-                        data.MoneyManagement,
-                        data.Name,
-                        data.Ticker,
-                        data.Scenario,
-                        data.Timeframe,
-                        data.IsForWatchingOnly));
-                    var bot2 = _taskCache.AddOrGetExisting(backupBot.Name, scalpingBot).Result;
-                    bot2.LoadBackup(backupBot);
-                    bot2.Start();
+                    var scalpingBotData = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
+                    bot = CreateScalpingBot(
+                        scalpingBotData.AccountName,
+                        scalpingBotData.MoneyManagement,
+                        backupBot.Name,
+                        scalpingBotData.Ticker,
+                        scalpingBotData.Scenario,
+                        scalpingBotData.Timeframe,
+                        scalpingBotData.IsForWatchingOnly);
+                    botTask = Task.Run(() => ((ITradingBot)bot).Start());
                     break;
                 case Enums.BotType.FlippingBot:
-                    var dataFlippingBot = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
-                    Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(CreateFlippingBot(
-                        dataFlippingBot.AccountName,
-                        dataFlippingBot.MoneyManagement,
-                        dataFlippingBot.Name,
-                        dataFlippingBot.Ticker,
-                        dataFlippingBot.Scenario,
-                        dataFlippingBot.Timeframe,
-                        dataFlippingBot.IsForWatchingOnly));
-                    var bot3 = _taskCache.AddOrGetExisting(backupBot.Name, flippingBot).Result;
-                    bot3.LoadBackup(backupBot);
-                    bot3.Start();
+                    var flippingBotData = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
+                    bot = CreateFlippingBot(
+                        flippingBotData.AccountName,
+                        flippingBotData.MoneyManagement,
+                        backupBot.Name,
+                        flippingBotData.Ticker,
+                        flippingBotData.Scenario,
+                        flippingBotData.Timeframe,
+                        flippingBotData.IsForWatchingOnly);
+                    botTask = Task.Run(() => ((ITradingBot)bot).Start());
                     break;
             }
 
-            ;
+            if (bot != null && botTask != null)
+            {
+                var botWrapper = new BotTaskWrapper(botTask, bot.GetType(), bot);
+                _botTasks.AddOrUpdate(backupBot.Name, botWrapper, (key, existingVal) => botWrapper);
+            }
         }
 
         public IBot CreateSimpleBot(string botName, Workflow workflow)