diff --git a/ProcessMaker/Cache/AbstractCacheFactory.php b/ProcessMaker/Cache/AbstractCacheFactory.php
new file mode 100644
index 0000000000..b3a8a2e18b
--- /dev/null
+++ b/ProcessMaker/Cache/AbstractCacheFactory.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace ProcessMaker\Cache;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\Monitoring\CacheMetricsDecorator;
+use ProcessMaker\Cache\Monitoring\CacheMetricsInterface;
+use ProcessMaker\Cache\Monitoring\RedisMetricsManager;
+
+abstract class AbstractCacheFactory implements CacheFactoryInterface
+{
+    protected static ?CacheInterface $testInstance = null;
+
+    /**
+     * Set a test instance for the factory
+     *
+     * @param CacheInterface|null $instance
+     */
+    public static function setTestInstance(?CacheInterface $instance): void
+    {
+        static::$testInstance = $instance;
+    }
+
+    /**
+     * Create a new cache instance with metrics monitoring
+     *
+     * @param CacheManager $cacheManager
+     * @param CacheMetricsInterface $metrics
+     * @return CacheInterface
+     */
+    public static function create(CacheManager $cacheManager, CacheMetricsInterface $metrics): CacheInterface
+    {
+        if (static::$testInstance !== null) {
+            return static::$testInstance;
+        }
+
+        // Create base cache instance
+        $cache = static::createInstance($cacheManager);
+
+        // Wrap with metrics decorator
+        return new CacheMetricsDecorator($cache, $metrics);
+    }
+
+    /**
+     * Get the current cache instance
+     *
+     * @return CacheInterface
+     */
+    protected static function getInstance(): CacheInterface
+    {
+        return static::create(app('cache'), app()->make(RedisMetricsManager::class));
+    }
+
+    /**
+     * Create the specific cache instance
+     *
+     * @param CacheManager $cacheManager
+     * @return CacheInterface
+     */
+    abstract protected static function createInstance(CacheManager $cacheManager): CacheInterface;
+}
diff --git a/ProcessMaker/Cache/CacheFactoryInterface.php b/ProcessMaker/Cache/CacheFactoryInterface.php
new file mode 100644
index 0000000000..5d910024a8
--- /dev/null
+++ b/ProcessMaker/Cache/CacheFactoryInterface.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\Monitoring\CacheMetricsInterface;
+
+interface CacheFactoryInterface
+{
+    /**
+     * Create a new cache instance with metrics monitoring
+     *
+     * @param CacheManager $cacheManager
+     * @param CacheMetricsInterface $metrics
+     * @return CacheInterface
+     */
+    public static function create(CacheManager $cacheManager, CacheMetricsInterface $metrics): CacheInterface;
+}
diff --git a/ProcessMaker/Cache/CacheInterface.php b/ProcessMaker/Cache/CacheInterface.php
index 24b127750d..bf0f98a4d7 100644
--- a/ProcessMaker/Cache/CacheInterface.php
+++ b/ProcessMaker/Cache/CacheInterface.php
@@ -72,4 +72,12 @@ public function has(string $key): bool;
      * @return bool True if the item is missing from the cache, false otherwise.
      */
     public function missing(string $key): bool;
+
+    /**
+     * Creates a cache key based on provided parameters
+     *
+     * @param array $params Key parameters
+     * @return string Generated cache key
+     */
+    public function createKey(array $params): string;
 }
diff --git a/ProcessMaker/Cache/CacheManagerBase.php b/ProcessMaker/Cache/CacheManagerBase.php
index f7545504e3..3c3e4219ae 100644
--- a/ProcessMaker/Cache/CacheManagerBase.php
+++ b/ProcessMaker/Cache/CacheManagerBase.php
@@ -40,6 +40,7 @@ public function getKeysByPattern(string $pattern, string $connection = null, str
         try {
             // Get all keys
             $keys = Redis::connection($connection)->keys($prefix . '*');
+
             // Filter keys by pattern
             return array_filter($keys, fn ($key) => preg_match('/' . $pattern . '/', $key));
         } catch (Exception $e) {
diff --git a/ProcessMaker/Cache/Monitoring/CacheMetricsDecorator.php b/ProcessMaker/Cache/Monitoring/CacheMetricsDecorator.php
index fb567e207f..f0c54aa7cc 100644
--- a/ProcessMaker/Cache/Monitoring/CacheMetricsDecorator.php
+++ b/ProcessMaker/Cache/Monitoring/CacheMetricsDecorator.php
@@ -4,15 +4,14 @@
 
 use ProcessMaker\Cache\CacheInterface;
 use ProcessMaker\Cache\Monitoring\CacheMetricsInterface;
-use ProcessMaker\Cache\Screens\ScreenCacheInterface;
 
 /**
  * Decorator class that adds metrics tracking about cache operations
  * including hits, misses, write sizes, and timing information.
  */
-class CacheMetricsDecorator implements CacheInterface, ScreenCacheInterface
+class CacheMetricsDecorator implements CacheInterface
 {
-    protected CacheInterface|ScreenCacheInterface $cache;
+    protected CacheInterface $cache;
 
     protected CacheMetricsInterface $metrics;
 
@@ -22,27 +21,22 @@ class CacheMetricsDecorator implements CacheInterface, ScreenCacheInterface
      * @param CacheInterface|ScreenCacheInterface $cache The cache implementation to decorate
      * @param CacheMetricsInterface $metrics The metrics implementation to use
      */
-    public function __construct(CacheInterface|ScreenCacheInterface $cache, CacheMetricsInterface $metrics)
+    public function __construct(CacheInterface $cache, CacheMetricsInterface $metrics)
     {
         $this->cache = $cache;
         $this->metrics = $metrics;
     }
 
     /**
-     * Create a cache key for screen data
+     * Create a cache key based on provided parameters
      *
-     * @param int $processId Process ID
-     * @param int $processVersionId Process version ID
-     * @param string $language Language code
-     * @param int $screenId Screen ID
-     * @param int $screenVersionId Screen version ID
+     * @param array $params Key parameters
      * @return string Generated cache key
-     * @throws \RuntimeException If underlying cache doesn't support createKey
      */
-    public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+    public function createKey(array $params): string
     {
-        if ($this->cache instanceof ScreenCacheInterface) {
-            return $this->cache->createKey($processId, $processVersionId, $language, $screenId, $screenVersionId);
+        if ($this->cache instanceof CacheInterface) {
+            return $this->cache->createKey($params);
         }
 
         throw new \RuntimeException('Underlying cache implementation does not support createKey method');
@@ -60,14 +54,21 @@ public function createKey(int $processId, int $processVersionId, string $languag
     public function get(string $key, mixed $default = null): mixed
     {
         $startTime = microtime(true);
+
+        // First check if the key exists
+        $exists = $this->cache->has($key);
+
+        // Get the value
         $value = $this->cache->get($key, $default);
+
         $endTime = microtime(true);
         $duration = $endTime - $startTime;
 
-        if ($value === $default) {
-            $this->metrics->recordMiss($key, $duration);
-        } else {
+        // Record metrics based on key existence, not value comparison
+        if ($exists) {
             $this->metrics->recordHit($key, $duration);
+        } else {
+            $this->metrics->recordMiss($key, $duration);
         }
 
         return $value;
@@ -146,13 +147,13 @@ public function missing(string $key): bool
      * @return bool
      * @throws \RuntimeException If underlying cache doesn't support invalidate
      */
-    public function invalidate(int $screenId, string $language): bool
+    public function invalidate($params): void
     {
-        if ($this->cache instanceof ScreenCacheInterface) {
-            return $this->cache->invalidate($screenId, $language);
+        if (!$this->cache instanceof CacheInterface) {
+            throw new \RuntimeException('Underlying cache implementation does not support invalidate method');
         }
 
-        throw new \RuntimeException('Underlying cache implementation does not support invalidate method');
+        $this->cache->invalidate($params);
     }
 
     /**
@@ -204,4 +205,18 @@ public function getOrCache(string $key, callable $callback): mixed
 
         return $value;
     }
+
+    /**
+     * Clear compiled assets from cache and record metrics
+     *
+     * This method clears compiled assets from the cache and records the operation
+     * as a write with size 0 since we are removing content rather than adding it.
+     * The execution time is measured but not currently used.
+     */
+    public function clearCompiledAssets(): void
+    {
+        $startTime = microtime(true);
+        $this->cache->clearCompiledAssets();
+        $timeTaken = microtime(true) - $startTime;
+    }
 }
diff --git a/ProcessMaker/Cache/Monitoring/RedisMetricsManager.php b/ProcessMaker/Cache/Monitoring/RedisMetricsManager.php
index c47d33e16e..942bc9d4a4 100644
--- a/ProcessMaker/Cache/Monitoring/RedisMetricsManager.php
+++ b/ProcessMaker/Cache/Monitoring/RedisMetricsManager.php
@@ -236,10 +236,15 @@ public function getSummary(): array
             $totalHitTime += $this->getHitAvgTime($key);
             $totalMissTime += $this->getMissAvgTime($key);
 
+            // Total represents the total number of cache access attempts (hits + misses)
+            // We need this sum to calculate hit_ratio and miss_ratio percentages
+            // Example: If hits=8 and misses=2, total=10, so hit_ratio=8/10=0.8 (80%) and miss_ratio=2/10=0.2 (20%)
+            $total = $hits + $misses;
             $metrics[$key] = [
                 'hits' => $hits,
                 'misses' => $misses,
-                'hit_ratio' => $hits + $misses > 0 ? $hits / ($hits + $misses) : 0,
+                'hit_ratio' => $total > 0 ? $hits / $total : 0,
+                'miss_ratio' => $total > 0 ? $misses / $total : 0,
                 'avg_hit_time' => $this->getHitAvgTime($key),
                 'avg_miss_time' => $this->getMissAvgTime($key),
                 'memory_usage' => $memory,
diff --git a/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php b/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php
index df53603ec2..9f413c34fe 100644
--- a/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php
+++ b/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php
@@ -2,10 +2,12 @@
 
 namespace ProcessMaker\Cache\Screens;
 
+use DateInterval;
 use Illuminate\Support\Facades\Storage;
+use ProcessMaker\Cache\CacheInterface;
 use ProcessMaker\Managers\ScreenCompiledManager;
 
-class LegacyScreenCacheAdapter implements ScreenCacheInterface
+class LegacyScreenCacheAdapter implements CacheInterface
 {
     protected ScreenCompiledManager $compiledManager;
 
@@ -17,14 +19,20 @@ public function __construct(ScreenCompiledManager $compiledManager)
     /**
      * Create a cache key for a screen
      */
-    public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+    public function createKey(array $params): string
     {
+        // Validate required parameters
+        if (!isset($params['process_id'], $params['process_version_id'], $params['language'],
+            $params['screen_id'], $params['screen_version_id'])) {
+            throw new \InvalidArgumentException('Missing required parameters for screen cache key');
+        }
+
         return $this->compiledManager->createKey(
-            (string) $processId,
-            (string) $processVersionId,
-            $language,
-            (string) $screenId,
-            (string) $screenVersionId
+            (string) $params['process_id'],
+            (string) $params['process_version_id'],
+            $params['language'],
+            (string) $params['screen_id'],
+            (string) $params['screen_version_id']
         );
     }
 
@@ -38,11 +46,40 @@ public function get(string $key, mixed $default = null): mixed
         return $content ?? $default;
     }
 
+    /**
+     * Get a value from the cache, or store the value from the callback if it doesn't exist
+     *
+     * @param string $key The key to look up
+     * @param callable $callback The callback that will return the value to store
+     * @return mixed The value from cache or the callback
+     * @throws \InvalidArgumentException
+     */
+    public function getOrCache(string $key, callable $callback): mixed
+    {
+        $value = $this->get($key);
+
+        if ($value !== null) {
+            return $value;
+        }
+
+        $value = $callback();
+        $this->set($key, $value);
+
+        return $value;
+    }
+
     /**
      * Store a screen in cache
+     *
+     * @param string $key The key of the item to store
+     * @param mixed $value The value of the item to store
+     * @param DateInterval|int|null $ttl Optional TTL value
+     * @return bool True on success and false on failure
      */
-    public function set(string $key, mixed $value): bool
+    public function set(string $key, mixed $value, DateInterval|int|null $ttl = null): bool
     {
+        // Note: The legacy compiled manager doesn't support TTL,
+        // so we ignore the TTL parameter for backward compatibility
         $this->compiledManager->storeCompiledContent($key, $value);
 
         return true;
@@ -86,9 +123,19 @@ public function missing(string $key): bool
      * @param int $screenId Screen ID
      * @return bool
      */
-    public function invalidate(int $screenId, string $language): bool
+    public function invalidate($params): void
     {
         // Get all files from storage that match the pattern for this screen ID
-        return $this->compiledManager->deleteScreenCompiledContent($screenId, $language);
+        $screenId = $params['screen_id'];
+        $language = $params['language'];
+        $this->compiledManager->deleteScreenCompiledContent($screenId, $language);
+    }
+
+    /**
+     * Clear all compiled screen assets
+     */
+    public function clearCompiledAssets(): void
+    {
+        $this->compiledManager->clearCompiledAssets();
     }
 }
diff --git a/ProcessMaker/Cache/Screens/ScreenCacheFactory.php b/ProcessMaker/Cache/Screens/ScreenCacheFactory.php
index 0fa77ee319..5c29b19cf3 100644
--- a/ProcessMaker/Cache/Screens/ScreenCacheFactory.php
+++ b/ProcessMaker/Cache/Screens/ScreenCacheFactory.php
@@ -2,59 +2,37 @@
 
 namespace ProcessMaker\Cache\Screens;
 
-use Illuminate\Support\Facades\Config;
-use ProcessMaker\Cache\Monitoring\CacheMetricsDecorator;
-use ProcessMaker\Cache\Monitoring\RedisMetricsManager;
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\AbstractCacheFactory;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Cache\Screens\LegacyScreenCacheAdapter;
 use ProcessMaker\Cache\Screens\ScreenCacheManager;
 use ProcessMaker\Managers\ScreenCompiledManager;
 
-class ScreenCacheFactory
+class ScreenCacheFactory extends AbstractCacheFactory
 {
-    private static ?ScreenCacheInterface $testInstance = null;
-
     /**
-     * Set a test instance for the factory
+     * Create the specific screen cache instance
      *
-     * @param ScreenCacheInterface|null $instance
+     * @param CacheManager $cacheManager
+     * @return CacheInterface
      */
-    public static function setTestInstance(?ScreenCacheInterface $instance): void
+    protected static function createInstance(CacheManager $cacheManager): CacheInterface
     {
-        self::$testInstance = $instance;
-    }
+        $manager = config('screens.cache.manager', 'legacy');
 
-    /**
-     * Create a screen cache handler based on configuration
-     *
-     * @return ScreenCacheInterface
-     */
-    public static function create(): ScreenCacheInterface
-    {
-        if (self::$testInstance !== null) {
-            return self::$testInstance;
-        }
-
-        // Create the appropriate cache implementation
-        $manager = Config::get('screens.cache.manager', 'legacy');
-        $cache = $manager === 'new'
+        return $manager === 'new'
             ? app(ScreenCacheManager::class)
             : new LegacyScreenCacheAdapter(app()->make(ScreenCompiledManager::class));
-
-        // If already wrapped with metrics decorator, return as is
-        if ($cache instanceof CacheMetricsDecorator) {
-            return $cache;
-        }
-
-        // Wrap with metrics decorator if not already wrapped
-        return new CacheMetricsDecorator($cache, app()->make(RedisMetricsManager::class));
     }
 
     /**
      * Get the current screen cache instance
      *
-     * @return ScreenCacheInterface
+     * @return CacheInterface
      */
-    public static function getScreenCache(): ScreenCacheInterface
+    public static function getScreenCache(): CacheInterface
     {
-        return self::create();
+        return static::getInstance();
     }
 }
diff --git a/ProcessMaker/Cache/Screens/ScreenCacheInterface.php b/ProcessMaker/Cache/Screens/ScreenCacheInterface.php
deleted file mode 100644
index 179925c3f5..0000000000
--- a/ProcessMaker/Cache/Screens/ScreenCacheInterface.php
+++ /dev/null
@@ -1,63 +0,0 @@
-<?php
-
-namespace ProcessMaker\Cache\Screens;
-
-interface ScreenCacheInterface
-{
-    /**
-     * Create a cache key for a screen
-     */
-    public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
-
-    /**
-     * Get a screen from cache
-     */
-    public function get(string $key, mixed $default = null): mixed;
-
-    /**
-     * Store a screen in cache
-     */
-    public function set(string $key, mixed $value): bool;
-
-    /**
-     * Check if screen exists in cache
-     *
-     * @param string $key Screen cache key
-     * @return bool
-     */
-    public function has(string $key): bool;
-
-    /**
-     * Delete a screen from cache
-     *
-     * @param string $key Screen cache key
-     * @return bool
-     */
-    public function delete(string $key): bool;
-
-    /**
-     * Clear all screen caches
-     *
-     * @return bool
-     */
-    public function clear(): bool;
-
-    /**
-     * Check if screen is missing from cache
-     *
-     * @param string $key Screen cache key
-     * @return bool
-     */
-    public function missing(string $key): bool;
-
-    /**
-     * Invalidate cache for a specific screen
-     *
-     * @param int $screenId
-     * @return bool
-     */
-    public function invalidate(
-        int $screenId,
-        string $language,
-    ): bool;
-}
diff --git a/ProcessMaker/Cache/Screens/ScreenCacheManager.php b/ProcessMaker/Cache/Screens/ScreenCacheManager.php
index de96e974f3..cdf8e65d30 100644
--- a/ProcessMaker/Cache/Screens/ScreenCacheManager.php
+++ b/ProcessMaker/Cache/Screens/ScreenCacheManager.php
@@ -7,7 +7,7 @@
 use ProcessMaker\Managers\ScreenCompiledManager;
 use ProcessMaker\Models\Screen;
 
-class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+class ScreenCacheManager implements CacheInterface
 {
     protected CacheManager $cacheManager;
 
@@ -24,19 +24,22 @@ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $s
         $this->screenCompiler = $screenCompiler;
     }
 
-    /**
-     * Create a cache key for a screen
-     *
-     * @param int $processId Process ID
-     * @param int $processVersionId Process version ID
-     * @param string $language Language code
-     * @param int $screenId Screen ID
-     * @param int $screenVersionId Screen version ID
-     * @return string Cache key
-     */
-    public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+    public function createKey(array $params): string
     {
-        return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+        // Validate required parameters
+        if (!isset($params['process_id'], $params['process_version_id'], $params['language'],
+            $params['screen_id'], $params['screen_version_id'])) {
+            throw new \InvalidArgumentException('Missing required parameters for screen cache key');
+        }
+
+        return sprintf(
+            'screen_pid_%d_%d_%s_sid_%d_%d',
+            $params['process_id'],
+            $params['process_version_id'],
+            $params['language'],
+            $params['screen_id'],
+            $params['screen_version_id']
+        );
     }
 
     /**
@@ -147,10 +150,13 @@ public function missing(string $key): bool
      * @param string $language Language code
      * @return bool
      */
-    public function invalidate(int $screenId, string $language): bool
+    public function invalidate($params): void
     {
         // Get all keys from cache that match the pattern for this screen ID
         // TODO Improve this to avoid scanning the entire cache
+        //extract the params from the array
+        $screenId = $params['screen_id'];
+        $language = $params['language'];
         $pattern = "*_{$language}_sid_{$screenId}_*";
         $keys = $this->cacheManager->get($pattern);
 
@@ -158,7 +164,5 @@ public function invalidate(int $screenId, string $language): bool
         foreach ($keys as $key) {
             $this->cacheManager->forget($key);
         }
-
-        return true;
     }
 }
diff --git a/ProcessMaker/Cache/Settings/SettingCacheFacade.php b/ProcessMaker/Cache/Settings/SettingCacheFacade.php
index ce0609010b..b885b1ced9 100644
--- a/ProcessMaker/Cache/Settings/SettingCacheFacade.php
+++ b/ProcessMaker/Cache/Settings/SettingCacheFacade.php
@@ -8,8 +8,6 @@
  * Class SettingCacheFacade
  *
  * @mixin \ProcessMaker\Cache\Settings\SettingCacheManager
- *
- * @package ProcessMaker\Cache
  */
 class SettingCacheFacade extends Facade
 {
diff --git a/ProcessMaker/Cache/Settings/SettingCacheFactory.php b/ProcessMaker/Cache/Settings/SettingCacheFactory.php
new file mode 100644
index 0000000000..fac9818c41
--- /dev/null
+++ b/ProcessMaker/Cache/Settings/SettingCacheFactory.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace ProcessMaker\Cache\Settings;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\AbstractCacheFactory;
+use ProcessMaker\Cache\CacheInterface;
+
+class SettingCacheFactory extends AbstractCacheFactory
+{
+    /**
+     * Create the specific settings cache instance
+     *
+     * @param CacheManager $cacheManager
+     * @return CacheInterface
+     */
+    protected static function createInstance(CacheManager $cacheManager): CacheInterface
+    {
+        return new SettingCacheManager($cacheManager);
+    }
+
+    /**
+     * Get the current settings cache instance
+     *
+     * @return CacheInterface
+     */
+    public static function getSettingsCache(): CacheInterface
+    {
+        return static::getInstance();
+    }
+}
diff --git a/ProcessMaker/Cache/Settings/SettingCacheManager.php b/ProcessMaker/Cache/Settings/SettingCacheManager.php
index 1d967ee65f..4b1891960d 100644
--- a/ProcessMaker/Cache/Settings/SettingCacheManager.php
+++ b/ProcessMaker/Cache/Settings/SettingCacheManager.php
@@ -20,7 +20,6 @@ class SettingCacheManager extends CacheManagerBase implements CacheInterface
     public function __construct(CacheManager $cacheManager)
     {
         $this->manager = $cacheManager;
-
         $this->setCacheDriver();
     }
 
@@ -42,6 +41,29 @@ private function setCacheDriver(): void
         $this->cacheManager = $this->manager->store($cacheDriver);
     }
 
+    /**
+     * Create a cache key for a screen
+     *
+     * @param int $processId Process ID
+     * @param int $processVersionId Process Version ID
+     * @param string $language Language code
+     * @param int $screenId Screen ID
+     * @param int $screenVersionId Screen Version ID
+     * @return string The generated cache key
+     */
+    public function createKey(array $params): string
+    {
+        // Validate required parameters
+        if (!isset($params['key'])) {
+            throw new \InvalidArgumentException('Missing required parameters for settings cache key');
+        }
+
+        return sprintf(
+            'setting_%s',
+            $params['key']
+        );
+    }
+
     /**
      * Dynamically pass method calls to the cache manager.
      *
@@ -198,9 +220,11 @@ public function missing(string $key): bool
      *
      * @return void
      */
-    public function invalidate(string $key): void
+    public function invalidate($params): void
     {
         try {
+            //extract the params from the array
+            $key = $params['key'];
             $this->cacheManager->forget($key);
         } catch (\Exception $e) {
             Log::error($e->getMessage());
diff --git a/ProcessMaker/Console/Commands/CacheMetricsCommand.php b/ProcessMaker/Console/Commands/CacheMetricsCommand.php
index 87394681b8..d78ecfd1ee 100644
--- a/ProcessMaker/Console/Commands/CacheMetricsCommand.php
+++ b/ProcessMaker/Console/Commands/CacheMetricsCommand.php
@@ -118,6 +118,8 @@ protected function displaySummary(?string $type, string $format): void
                 'Key',
                 'Hits',
                 'Hit Ratio',
+                'Misses',
+                'Miss Ratio',
                 'Avg Time',
                 'Memory',
                 'Status',
@@ -128,6 +130,8 @@ protected function displaySummary(?string $type, string $format): void
                     $key,
                     number_format($metrics['hits']),
                     $this->formatPercentage($metrics['hit_ratio']),
+                    number_format($metrics['misses']),
+                    $this->formatPercentage($metrics['miss_ratio']),
                     sprintf('%.4f sec', $metrics['avg_hit_time']),
                     $this->formatBytes($metrics['memory_usage']),
                     $this->getPerformanceStatus($metrics['hit_ratio']),
diff --git a/ProcessMaker/Console/Commands/RevokeOauthAccessTokens.php b/ProcessMaker/Console/Commands/RevokeOauthAccessTokens.php
index c93a6a02fb..c353097921 100644
--- a/ProcessMaker/Console/Commands/RevokeOauthAccessTokens.php
+++ b/ProcessMaker/Console/Commands/RevokeOauthAccessTokens.php
@@ -2,10 +2,10 @@
 
 namespace ProcessMaker\Console\Commands;
 
+use Carbon\Carbon;
 use Illuminate\Console\Command;
 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\DB;
-use Carbon\Carbon;
 
 class RevokeOauthAccessTokens extends Command
 {
@@ -37,11 +37,13 @@ public function handle()
 
         if (!$name && !$after && !$clientId) {
             $this->error('At least one of --name, --after, or --client_id must be specified.');
+
             return;
         }
 
         if (!$noInteraction && !$this->confirm('Are you sure you want to revoke this certificate?')) {
             $this->info('Certificate revocation cancelled.');
+
             return;
         }
 
diff --git a/ProcessMaker/Contracts/CaseApiRepositoryInterface.php b/ProcessMaker/Contracts/CaseApiRepositoryInterface.php
index b71ffdd0d2..ccf978aaa6 100644
--- a/ProcessMaker/Contracts/CaseApiRepositoryInterface.php
+++ b/ProcessMaker/Contracts/CaseApiRepositoryInterface.php
@@ -15,6 +15,7 @@ interface CaseApiRepositoryInterface
      * @return Builder
      */
     public function getAllCases(Request $request): Builder;
+
     /**
      * Get all cases in progress
      *
@@ -23,6 +24,7 @@ public function getAllCases(Request $request): Builder;
      * @return Builder
      */
     public function getInProgressCases(Request $request): Builder;
+
     /**
      * Get all completed cases
      *
@@ -31,6 +33,7 @@ public function getInProgressCases(Request $request): Builder;
      * @return Builder
      */
     public function getCompletedCases(Request $request): Builder;
+
     /**
      * Search by case number or case title.
 
@@ -40,6 +43,7 @@ public function getCompletedCases(Request $request): Builder;
      * @return void
      */
     public function search(Request $request, Builder $query): void;
+
     /**
      * Filter the query.
      *
@@ -50,6 +54,7 @@ public function search(Request $request, Builder $query): void;
      * @return void
      */
     public function filterBy(Request $request, Builder $query): void;
+
     /**
      * Sort the query.
      *
diff --git a/ProcessMaker/Contracts/CaseRepositoryInterface.php b/ProcessMaker/Contracts/CaseRepositoryInterface.php
index 9ad880cb1b..42ab6f9ad2 100644
--- a/ProcessMaker/Contracts/CaseRepositoryInterface.php
+++ b/ProcessMaker/Contracts/CaseRepositoryInterface.php
@@ -14,6 +14,7 @@ interface CaseRepositoryInterface
      * @return void
      */
     public function create(ExecutionInstanceInterface $instance): void;
+
     /**
      * Update the case started.
      *
@@ -22,6 +23,7 @@ public function create(ExecutionInstanceInterface $instance): void;
      * @return void
      */
     public function update(ExecutionInstanceInterface $instance, TokenInterface $token): void;
+
     /**
      * Update the status of a case started.
      *
diff --git a/ProcessMaker/EncryptedData/EncryptedDataInterface.php b/ProcessMaker/EncryptedData/EncryptedDataInterface.php
index 4453f50d84..d2fdd75495 100644
--- a/ProcessMaker/EncryptedData/EncryptedDataInterface.php
+++ b/ProcessMaker/EncryptedData/EncryptedDataInterface.php
@@ -48,6 +48,6 @@ public function setIv(string $iv): void;
 
     /**
      * Get IV value
-    */
+     */
     public function getIv(): string;
 }
diff --git a/ProcessMaker/EncryptedData/Local.php b/ProcessMaker/EncryptedData/Local.php
index 2460db598f..b3fb1cb3e6 100644
--- a/ProcessMaker/EncryptedData/Local.php
+++ b/ProcessMaker/EncryptedData/Local.php
@@ -2,8 +2,8 @@
 
 namespace ProcessMaker\EncryptedData;
 
-use Illuminate\Support\Facades\App;
 use Illuminate\Encryption\Encrypter;
+use Illuminate\Support\Facades\App;
 use Illuminate\Support\Str;
 use ProcessMaker\EncryptedData\EncryptedDataInterface;
 use ProcessMaker\Models\EncryptedData;
@@ -40,7 +40,7 @@ public function encryptText(string $plainText, string $iv = null, string $key =
 
         // Store last $iv used
         self::$iv = $iv;
-        
+
         return $cipherText;
     }
 
diff --git a/ProcessMaker/EncryptedData/Vault.php b/ProcessMaker/EncryptedData/Vault.php
index 26023ca6b8..3eaa1e9653 100644
--- a/ProcessMaker/EncryptedData/Vault.php
+++ b/ProcessMaker/EncryptedData/Vault.php
@@ -16,7 +16,9 @@ class Vault implements EncryptedDataInterface
     public static $iv = '';
 
     private $host;
+
     private $token;
+
     private $transitKey;
 
     public function __construct()
@@ -94,7 +96,7 @@ public function changeKey(): void
 
             // Store new values
             $record->data = $cipherText;
-            $record->save(); 
+            $record->save();
         }
     }
 
@@ -121,7 +123,7 @@ public function getIv(): string
     /**
      * Build transit API object
      *
-     * @return \VaultPHP\SecretEngines\Engines\Transit\Transit
+     * @return Transit
      */
     private function buildTransitApi()
     {
diff --git a/ProcessMaker/Http/Controllers/Api/ScreenController.php b/ProcessMaker/Http/Controllers/Api/ScreenController.php
index f5749070c3..c7459c9fbf 100644
--- a/ProcessMaker/Http/Controllers/Api/ScreenController.php
+++ b/ProcessMaker/Http/Controllers/Api/ScreenController.php
@@ -3,10 +3,10 @@
 namespace ProcessMaker\Http\Controllers\Api;
 
 use Illuminate\Http\Request;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Events\ScreenCreated;
 use ProcessMaker\Events\ScreenDeleted;
 use ProcessMaker\Events\ScreenUpdated;
-use ProcessMaker\Facades\ScreenCompiledManager;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\ApiCollection;
 use ProcessMaker\Http\Resources\ApiResource;
@@ -304,7 +304,8 @@ public function update(Screen $screen, Request $request)
 
         // Clear the screens cache when a screen is updated. All cache is cleared
         // because we don't know which nested screens affect to other screens
-        ScreenCompiledManager::clearCompiledAssets();
+        $screenCache = ScreenCacheFactory::getScreenCache();
+        $screenCache->clearCompiledAssets();
 
         return response([], 204);
     }
diff --git a/ProcessMaker/Http/Controllers/Api/SettingController.php b/ProcessMaker/Http/Controllers/Api/SettingController.php
index d219c605e0..de90e2a461 100644
--- a/ProcessMaker/Http/Controllers/Api/SettingController.php
+++ b/ProcessMaker/Http/Controllers/Api/SettingController.php
@@ -6,6 +6,7 @@
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Storage;
+use ProcessMaker\Cache\Settings\SettingCacheFactory;
 use ProcessMaker\Events\SettingsUpdated;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\ApiCollection;
@@ -253,7 +254,13 @@ public function update(Setting $setting, Request $request)
         SettingsUpdated::dispatch($setting, $setting->getChanges(), $original);
 
         // Store the setting in the cache
-        \SettingCache::set($setting->key, $setting->refresh());
+        $settingCache = SettingCacheFactory::getSettingsCache();
+        //create key
+        $key = $settingCache->createKey([
+            'key' => $setting->key,
+        ]);
+        // set to cache with key and setting
+        $settingCache->set($key, $setting->refresh());
 
         return response([], 204);
     }
diff --git a/ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php b/ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php
index 46ce3f13b8..334c109077 100644
--- a/ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php
+++ b/ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php
@@ -115,16 +115,16 @@ public function showScreen($taskId)
         $screenVersion = $task->getScreenVersion();
 
         // Get the appropriate cache handler based on configuration
-        $screenCache = ScreenCacheFactory::create();
 
+        $screenCache = ScreenCacheFactory::getScreenCache();
         // Create cache key
-        $key = $screenCache->createKey(
-            (int) $processId,
-            (int) $processVersionId,
-            $language,
-            (int) $screenVersion->screen_id,
-            (int) $screenVersion->id
-        );
+        $key = $screenCache->createKey([
+            'process_id' => (int) $processId,
+            'process_version_id' => (int) $processVersionId,
+            'language' => $language,
+            'screen_id' => (int) $screenVersion->screen_id,
+            'screen_version_id' => (int) $screenVersion->id,
+        ]);
 
         // Try to get the screen from cache
         $translatedScreen = $screenCache->get($key);
diff --git a/ProcessMaker/ImportExport/Utils.php b/ProcessMaker/ImportExport/Utils.php
index ef96f7f918..750c48bbe5 100644
--- a/ProcessMaker/ImportExport/Utils.php
+++ b/ProcessMaker/ImportExport/Utils.php
@@ -41,7 +41,7 @@ public static function getElementByPath($document, $path)
     {
         $elements = self::getElementsByPath($document, $path);
         if ($elements->count() !== 1) {
-            throw new \Exception('Invalid xpath');
+            throw new Exception('Invalid xpath');
         }
 
         return $elements->item(0);
diff --git a/ProcessMaker/InboxRules/MatchingTasks.php b/ProcessMaker/InboxRules/MatchingTasks.php
index 8170ccc898..a8b659a0fa 100644
--- a/ProcessMaker/InboxRules/MatchingTasks.php
+++ b/ProcessMaker/InboxRules/MatchingTasks.php
@@ -15,7 +15,7 @@
 class MatchingTasks
 {
     /**
-     * @param  \ProcessMaker\Models\ProcessRequestToken  $task
+     * @param  ProcessRequestToken  $task
      *
      * @return array
      */
@@ -62,9 +62,9 @@ public function matchesSavedSearch($rule, $task): bool
     }
 
     /**
-     * @param  \ProcessMaker\Models\InboxRule  $inboxRule
+     * @param  InboxRule  $inboxRule
      *
-     * @return \Illuminate\Support\Collection
+     * @return Collection
      */
     public function get(InboxRule $inboxRule) : Collection
     {
diff --git a/ProcessMaker/Listeners/InvalidateScreenCacheOnTranslationChange.php b/ProcessMaker/Listeners/InvalidateScreenCacheOnTranslationChange.php
index 129c6af448..e4da61b70f 100644
--- a/ProcessMaker/Listeners/InvalidateScreenCacheOnTranslationChange.php
+++ b/ProcessMaker/Listeners/InvalidateScreenCacheOnTranslationChange.php
@@ -16,7 +16,11 @@ public function handle(TranslationChanged $event): void
     {
         try {
             if ($event->screenId) {
-                $this->invalidateScreen($event->screenId, $event->language);
+                $params = [
+                    'screen_id' => $event->screenId,
+                    'language' => $event->language,
+                ];
+                ScreenCacheFactory::getScreenCache()->invalidate($params);
             }
         } catch (\Exception $e) {
             Log::error('Failed to invalidate screen cache', [
diff --git a/ProcessMaker/Mail/TaskActionByEmail.php b/ProcessMaker/Mail/TaskActionByEmail.php
index 65ed8a40d7..158807368f 100644
--- a/ProcessMaker/Mail/TaskActionByEmail.php
+++ b/ProcessMaker/Mail/TaskActionByEmail.php
@@ -38,7 +38,7 @@ public function sendAbeEmail($config, $to, $data)
             $emailServer = $config['emailServer'] ?? 0;
             $subject = $config['subject'] ?? '';
             $emailScreenRef = $config['screenEmailRef'] ?? 0;
-    
+
             $emailConfig = [
                 'subject' => $this->mustache($subject, $data),
                 'addEmails' => $to,
@@ -47,7 +47,7 @@ public function sendAbeEmail($config, $to, $data)
                 'json_data' => '{}',
                 'emailServer' => $emailServer,
             ];
-    
+
             if (!empty($emailScreenRef)) {
                 // Retrieve and render custom screen if specified
                 $customScreen = Screen::findOrFail($emailScreenRef);
@@ -56,10 +56,9 @@ public function sendAbeEmail($config, $to, $data)
                 // Default message if no custom screen is configured
                 $emailConfig['body'] = __('No screen configured');
             }
-    
+
             // Send the email using emailProvider
             $this->emailProvider->send($emailConfig);
-    
         } catch (\Exception $e) {
             Log::error('Error sending ABE email', [
                 'to' => $to,
diff --git a/ProcessMaker/Managers/ModelerManager.php b/ProcessMaker/Managers/ModelerManager.php
index 5c847233c2..e762e3ef23 100644
--- a/ProcessMaker/Managers/ModelerManager.php
+++ b/ProcessMaker/Managers/ModelerManager.php
@@ -5,6 +5,7 @@
 class ModelerManager
 {
     private $javascriptRegistry;
+
     private $javascriptParamsRegistry;
 
     /**
@@ -48,6 +49,7 @@ public function getScripts()
     {
         return $this->javascriptRegistry;
     }
+
     /**
      * Retrieve the JavaScript parameters registry.
      *
diff --git a/ProcessMaker/Managers/SessionControlManager.php b/ProcessMaker/Managers/SessionControlManager.php
index 8231c6c2aa..9079b02f60 100644
--- a/ProcessMaker/Managers/SessionControlManager.php
+++ b/ProcessMaker/Managers/SessionControlManager.php
@@ -16,9 +16,11 @@
 class SessionControlManager
 {
     const IP_RESTRICTION_KEY = 'session-control.ip_restriction';
+
     const DEVICE_RESTRICTION_KEY = 'session-control.device_restriction';
 
     private ?User $user;
+
     private string $clientIp;
 
     public function __construct(?User $user, string $clientIp)
@@ -28,7 +30,6 @@ public function __construct(?User $user, string $clientIp)
     }
 
     /**
-     *
      * If the session is blocked by some of the ProcessMaker policies, returns true, false otherwise
      *
      * @return bool
@@ -47,7 +48,6 @@ public function isSessionBlocked()
         return false;
     }
 
-
     /**
      * Checks if a user's session is a duplicate based on their IP address.
      *
@@ -57,6 +57,7 @@ public function blockSessionByIp(): bool
     {
         // Get the user's most recent session
         $session = $this->user->sessions->sortByDesc('created_at')->first();
+
         // Get the user's current IP address
         return $session->ip_address === $this->clientIp;
     }
@@ -118,4 +119,4 @@ private function formatDeviceInfo(string $deviceName, string $deviceType, string
     {
         return Str::slug($deviceName . '-' . $deviceType . '-' . $devicePlatform);
     }
-}
\ No newline at end of file
+}
diff --git a/ProcessMaker/Managers/TaskSchedulerManager.php b/ProcessMaker/Managers/TaskSchedulerManager.php
index d866ec421d..67f419e67e 100644
--- a/ProcessMaker/Managers/TaskSchedulerManager.php
+++ b/ProcessMaker/Managers/TaskSchedulerManager.php
@@ -52,7 +52,7 @@ private function removeExpiredLocks()
     /**
      * Register in the database any Timer Start Event of a process
      *
-     * @param \ProcessMaker\Models\Process $process
+     * @param Process $process
      * @return void
      * @internal param string $script Path to the javascript to load
      */
@@ -139,9 +139,9 @@ public function scheduleTasks()
         $today = $this->today();
         try {
             /**
-             * This validation is removed; the database schema should exist before 
+             * This validation is removed; the database schema should exist before
              * any initiation of 'jobs' and 'schedule'.
-             * 
+             *
              * if (!Schema::hasTable('scheduled_tasks')) {
              *     return;
              * }
@@ -206,7 +206,7 @@ public function scheduleTasks()
                 }
             }
         } catch (PDOException $e) {
-            Log::error('The connection to the database had problems (scheduleTasks): ' .  $e->getMessage());
+            Log::error('The connection to the database had problems (scheduleTasks): ' . $e->getMessage());
         }
     }
 
diff --git a/ProcessMaker/Models/Bundle.php b/ProcessMaker/Models/Bundle.php
index a53fa3ceef..2dfc66f3ae 100644
--- a/ProcessMaker/Models/Bundle.php
+++ b/ProcessMaker/Models/Bundle.php
@@ -125,7 +125,7 @@ public function addAsset(ProcessMakerModel $asset)
             'asset_id' => $asset->id,
         ]);
     }
-    
+
     public function addAssetToBundles(ProcessMakerModel $asset)
     {
         $message = null;
@@ -134,6 +134,7 @@ public function addAssetToBundles(ProcessMakerModel $asset)
         } catch (ValidationException $ve) {
             $message = $ve->getMessage();
         }
+
         return $message;
     }
 
diff --git a/ProcessMaker/Models/DataStore.php b/ProcessMaker/Models/DataStore.php
index 21ad708063..bb7dad4b05 100644
--- a/ProcessMaker/Models/DataStore.php
+++ b/ProcessMaker/Models/DataStore.php
@@ -21,12 +21,12 @@ class DataStore implements DataStoreInterface
     private $removed = [];
 
     /**
-     * @var \ProcessMaker\Nayra\Contracts\Bpmn\ProcessInterface
+     * @var ProcessInterface
      */
     private $process;
 
     /**
-     * @var \ProcessMaker\Nayra\Contracts\Bpmn\ItemDefinitionInterface
+     * @var ItemDefinitionInterface
      */
     private $itemSubject;
 
@@ -43,7 +43,7 @@ public function getOwnerProcess()
     /**
      * Get Process of the application.
      *
-     * @param \ProcessMaker\Nayra\Contracts\Bpmn\ProcessInterface $process
+     * @param ProcessInterface $process
      *
      * @return ProcessInterface
      */
diff --git a/ProcessMaker/Models/Embed.php b/ProcessMaker/Models/Embed.php
index 6e74064efa..8a69e92821 100644
--- a/ProcessMaker/Models/Embed.php
+++ b/ProcessMaker/Models/Embed.php
@@ -4,8 +4,8 @@
 
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use ProcessMaker\Models\ProcessMakerModel;
-use ProcessMaker\Traits\HasUuids;
 use ProcessMaker\Traits\Exportable;
+use ProcessMaker\Traits\HasUuids;
 
 class Embed extends ProcessMakerModel
 {
@@ -28,7 +28,7 @@ class Embed extends ProcessMakerModel
         'created_at',
         'updated_at',
     ];
-    
+
     /**
      * The attributes that are mass assignable.
      *
@@ -67,7 +67,7 @@ public function process()
      */
     public function saveProcessEmbed(Process $process, $properties, $key = 'uuid')
     {
-        $embed = new Embed();
+        $embed = new self();
         // Define the values
         $values = [
             'model_id' => $process->id,
@@ -75,7 +75,7 @@ public function saveProcessEmbed(Process $process, $properties, $key = 'uuid')
             'mime_type' => 'text/url',
             'custom_properties' => json_encode([
                 'url' => $properties['url'],
-                'type' => $properties['type']
+                'type' => $properties['type'],
             ]),
         ];
         // Review if the uuid was defined
diff --git a/ProcessMaker/Models/EncryptedData.php b/ProcessMaker/Models/EncryptedData.php
index 3cd1d77e22..b6c53f5323 100644
--- a/ProcessMaker/Models/EncryptedData.php
+++ b/ProcessMaker/Models/EncryptedData.php
@@ -27,7 +27,7 @@ class EncryptedData extends ProcessMakerModel
         'created_at',
         'updated_at',
     ];
-    
+
     /**
      * The attributes that are mass assignable.
      *
@@ -41,12 +41,12 @@ class EncryptedData extends ProcessMakerModel
 
     /**
      * Check user permission for the encrypted data
-     * 
+     *
      * @param string $userId
      * @param string $screenId
      * @param string $fieldName
      *
-     * @throws \Illuminate\Validation\ValidationException
+     * @throws ValidationException
      */
     public static function checkUserPermission($userId, $screenId, $fieldName)
     {
diff --git a/ProcessMaker/Models/FormalExpression.php b/ProcessMaker/Models/FormalExpression.php
index 8f40df7032..0f42344016 100644
--- a/ProcessMaker/Models/FormalExpression.php
+++ b/ProcessMaker/Models/FormalExpression.php
@@ -35,7 +35,7 @@ class FormalExpression implements FormalExpressionInterface
 
     /**
      * FEEL expression object to be used to evaluate
-     * @var \Symfony\Component\ExpressionLanguage\ExpressionLanguage
+     * @var ExpressionLanguage
      */
     private $feelExpression;
 
diff --git a/ProcessMaker/Models/ProcessAbeRequestToken.php b/ProcessMaker/Models/ProcessAbeRequestToken.php
index dd86e275c9..6313d9b1d1 100644
--- a/ProcessMaker/Models/ProcessAbeRequestToken.php
+++ b/ProcessMaker/Models/ProcessAbeRequestToken.php
@@ -37,7 +37,7 @@ class ProcessAbeRequestToken extends ProcessMakerModel
         'data',
         'is_answered',
         'require_login',
-        'answered_at'
+        'answered_at',
     ];
 
     public static function rules(): array
diff --git a/ProcessMaker/Models/ProcessLaunchpad.php b/ProcessMaker/Models/ProcessLaunchpad.php
index cd82d39bdd..3f9fda1d5f 100644
--- a/ProcessMaker/Models/ProcessLaunchpad.php
+++ b/ProcessMaker/Models/ProcessLaunchpad.php
@@ -3,8 +3,8 @@
 namespace ProcessMaker\Models;
 
 use Illuminate\Database\Eloquent\Factories\HasFactory;
-use ProcessMaker\Traits\HasUuids;
 use ProcessMaker\Traits\Exportable;
+use ProcessMaker\Traits\HasUuids;
 
 class ProcessLaunchpad extends ProcessMakerModel
 {
diff --git a/ProcessMaker/Models/ScriptDockerCopyingFilesTrait.php b/ProcessMaker/Models/ScriptDockerCopyingFilesTrait.php
index 1b57b76c4d..343694d3b9 100644
--- a/ProcessMaker/Models/ScriptDockerCopyingFilesTrait.php
+++ b/ProcessMaker/Models/ScriptDockerCopyingFilesTrait.php
@@ -19,7 +19,7 @@ trait ScriptDockerCopyingFilesTrait
      * @param array $options
      *
      * @return array
-     * @throws \RuntimeException
+     * @throws RuntimeException
      */
     protected function executeCopying(array $options)
     {
@@ -47,7 +47,7 @@ protected function executeCopying(array $options)
      * @param string $parameters
      *
      * @return string
-     * @throws \RuntimeException
+     * @throws RuntimeException
      */
     private function createContainer($image, $command, $parameters = '')
     {
@@ -74,7 +74,7 @@ private function createContainer($image, $command, $parameters = '')
      * @param string $path
      * @param string $content
      *
-     * @throws \RuntimeException
+     * @throws RuntimeException
      */
     private function putInContainer($container, $path, $content)
     {
@@ -94,7 +94,7 @@ private function putInContainer($container, $path, $content)
      * @param string $container
      * @param string $dest
      *
-     * @throws \RuntimeException
+     * @throws RuntimeException
      */
     private function execCopy($source, $container, $dest)
     {
@@ -111,7 +111,7 @@ private function execCopy($source, $container, $dest)
      * @param string $path
      *
      * @return string
-     * @throws \RuntimeException
+     * @throws RuntimeException
      */
     private function getFromContainer($container, $path)
     {
diff --git a/ProcessMaker/Models/Setting.php b/ProcessMaker/Models/Setting.php
index 16bc451cd9..c023379b25 100644
--- a/ProcessMaker/Models/Setting.php
+++ b/ProcessMaker/Models/Setting.php
@@ -7,6 +7,7 @@
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\Rule;
 use Log;
+use ProcessMaker\Cache\Settings\SettingCacheFactory;
 use ProcessMaker\Traits\ExtendedPMQL;
 use ProcessMaker\Traits\SerializeToIso8601;
 use Spatie\MediaLibrary\HasMedia;
@@ -148,15 +149,18 @@ public static function messages()
      */
     public static function byKey(string $key)
     {
-        $setting = \SettingCache::get($key);
-
-        if ($setting === null) {
+        $settingCache = SettingCacheFactory::getSettingsCache();
+        $settingKey = $settingCache->createKey([
+            'key' => $key,
+        ]);
+        $exists = $settingCache->has($settingKey);
+
+        // if the setting is not in the cache, get it from the database and store it in the cache
+        if ($exists) {
+            $setting = $settingCache->get($settingKey);
+        } else {
             $setting = (new self)->where('key', $key)->first();
-
-            // Store the setting in the cache if it exists
-            if ($setting !== null) {
-                \SettingCache::set($key, $setting);
-            }
+            $settingCache->set($settingKey, $setting);
         }
 
         return $setting;
diff --git a/ProcessMaker/Models/TimerExpression.php b/ProcessMaker/Models/TimerExpression.php
index 8fab7b99e4..af70744e23 100644
--- a/ProcessMaker/Models/TimerExpression.php
+++ b/ProcessMaker/Models/TimerExpression.php
@@ -113,7 +113,7 @@ private function mustacheTimerExpression($expression, $data)
     /**
      * Get a DateTime if the expression is a date.
      *
-     * @return \DateTime
+     * @return DateTime
      */
     protected function getDateExpression($expression)
     {
@@ -180,7 +180,7 @@ protected function getMultipleCycleExpression($expression)
     /**
      * Get a DateInterval if the expression is a duration.
      *
-     * @return \DateInterval
+     * @return DateInterval
      */
     protected function getDurationExpression($expression)
     {
diff --git a/ProcessMaker/Models/TokenAssignableUsers.php b/ProcessMaker/Models/TokenAssignableUsers.php
index 55140bef13..c452d220d3 100644
--- a/ProcessMaker/Models/TokenAssignableUsers.php
+++ b/ProcessMaker/Models/TokenAssignableUsers.php
@@ -64,7 +64,7 @@ public function initRelation(array $models, $relation)
      * Match the eagerly loaded results to their parents.
      *
      * @param  array   $models
-     * @param  \Illuminate\Database\Eloquent\Collection  $results
+     * @param  Collection  $results
      * @param  string  $relation
      * @return array
      */
diff --git a/ProcessMaker/Nayra/Managers/WorkflowManagerDefault.php b/ProcessMaker/Nayra/Managers/WorkflowManagerDefault.php
index d688f10ad5..0f757aa7e2 100644
--- a/ProcessMaker/Nayra/Managers/WorkflowManagerDefault.php
+++ b/ProcessMaker/Nayra/Managers/WorkflowManagerDefault.php
@@ -145,7 +145,7 @@ public function triggerBoundaryEvent(
      * @param array $data
      * @param callable $beforeStart
      *
-     * @return \ProcessMaker\Models\ProcessRequest
+     * @return ProcessRequest
      */
     public function triggerStartEvent(Definitions $definitions, StartEventInterface $event, array $data, callable $beforeStart = null)
     {
@@ -163,7 +163,7 @@ public function triggerStartEvent(Definitions $definitions, StartEventInterface
      * @param ProcessInterface $process
      * @param array $data
      *
-     * @return \ProcessMaker\Models\ProcessRequest
+     * @return ProcessRequest
      */
     public function callProcess(Definitions $definitions, ProcessInterface $process, array $data)
     {
@@ -410,6 +410,7 @@ public function registerServiceImplementation($implementation, $class)
                 . ' must be an instance of '
                 . ServiceTaskImplementationInterface::class
             );
+
             return false;
         }
 
diff --git a/ProcessMaker/Observers/SettingObserver.php b/ProcessMaker/Observers/SettingObserver.php
index 6815d67bc7..3ae202d91a 100644
--- a/ProcessMaker/Observers/SettingObserver.php
+++ b/ProcessMaker/Observers/SettingObserver.php
@@ -4,6 +4,7 @@
 
 use Exception;
 use Illuminate\Support\Facades\Log;
+use ProcessMaker\Cache\Settings\SettingCacheFactory;
 use ProcessMaker\Models\Setting;
 
 class SettingObserver
@@ -11,7 +12,7 @@ class SettingObserver
     /**
      * Handle the setting "created" event.
      *
-     * @param  \ProcessMaker\Models\Setting  $setting
+     * @param  Setting  $setting
      * @return void
      */
     public function saving(Setting $setting)
@@ -39,7 +40,7 @@ public function saving(Setting $setting)
                     try {
                         $return = json_decode($config);
                         $return = json_encode($return);
-                    } catch (\Exception $e) {
+                    } catch (Exception $e) {
                         $return = $config;
                     }
                 } else {
@@ -55,7 +56,7 @@ public function saving(Setting $setting)
                     try {
                         $return = json_decode($config, true);
                         $return = json_encode($return);
-                    } catch (\Exception $e) {
+                    } catch (Exception $e) {
                         $return = $config;
                     }
                 } else {
@@ -66,17 +67,20 @@ public function saving(Setting $setting)
                 break;
         }
 
-        \SettingCache::invalidate($setting->key);
+        $settingCache = SettingCacheFactory::getSettingsCache();
+        $settingCache->invalidate(['key' => $setting->key]);
     }
 
     /**
      * Handle the setting "deleted" event.
      *
-     * @param  \ProcessMaker\Models\Setting  $setting
+     * @param  Setting  $setting
      * @return void
      */
     public function deleted(Setting $setting): void
     {
-        \SettingCache::invalidate($setting->key);
+        $settingCache = SettingCacheFactory::getSettingsCache();
+        //invalidate the setting cache
+        $settingCache->invalidate(['key' => $setting->key]);
     }
 }
diff --git a/ProcessMaker/Providers/CacheServiceProvider.php b/ProcessMaker/Providers/CacheServiceProvider.php
index c6a19b48f4..1d3cb5fdbe 100644
--- a/ProcessMaker/Providers/CacheServiceProvider.php
+++ b/ProcessMaker/Providers/CacheServiceProvider.php
@@ -3,12 +3,12 @@
 namespace ProcessMaker\Providers;
 
 use Illuminate\Support\ServiceProvider;
-use ProcessMaker\Cache\Monitoring\CacheMetricsDecorator;
 use ProcessMaker\Cache\Monitoring\CacheMetricsInterface;
 use ProcessMaker\Cache\Monitoring\RedisMetricsManager;
 use ProcessMaker\Cache\Screens\LegacyScreenCacheAdapter;
 use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Cache\Settings\SettingCacheFactory;
 use ProcessMaker\Cache\Settings\SettingCacheManager;
 use ProcessMaker\Managers\ScreenCompiledManager;
 
@@ -21,61 +21,27 @@ public function register(): void
 
         // Register screen cache with metrics
         $this->app->singleton(ScreenCacheManager::class, function ($app) {
-            $cache = new ScreenCacheManager(
+            return ScreenCacheFactory::create(
                 $app['cache'],
-                $app->make(ScreenCompiledManager::class)
-            );
-
-            return new CacheMetricsDecorator(
-                $cache,
                 $app->make(CacheMetricsInterface::class)
             );
         });
 
         // Register settings cache with metrics
         $this->app->singleton(SettingCacheManager::class, function ($app) {
-            $cache = new SettingCacheManager($app['cache']);
-
-            return new CacheMetricsDecorator(
-                $cache,
+            return SettingCacheFactory::create(
+                $app['cache'],
                 $app->make(CacheMetricsInterface::class)
             );
         });
 
         // Register legacy screen cache with metrics
         $this->app->bind(LegacyScreenCacheAdapter::class, function ($app) {
-            $cache = new LegacyScreenCacheAdapter(
-                $app->make(ScreenCompiledManager::class)
-            );
-
-            return new CacheMetricsDecorator(
-                $cache,
+            return ScreenCacheFactory::create(
+                $app['cache'],
                 $app->make(CacheMetricsInterface::class)
             );
         });
-
-        // Update the screen cache factory to use the metrics-enabled instances
-        $this->app->extend(ScreenCacheFactory::class, function ($factory, $app) {
-            return new class($app) extends ScreenCacheFactory {
-                protected $app;
-
-                public function __construct($app)
-                {
-                    $this->app = $app;
-                }
-
-                public static function create(): ScreenCacheInterface
-                {
-                    $manager = config('screens.cache.manager', 'legacy');
-
-                    if ($manager === 'new') {
-                        return app(ScreenCacheManager::class);
-                    }
-
-                    return app(LegacyScreenCacheAdapter::class);
-                }
-            };
-        });
     }
 
     public function boot(): void
diff --git a/ProcessMaker/Providers/EncryptedDataServiceProvider.php b/ProcessMaker/Providers/EncryptedDataServiceProvider.php
index c378b94a8b..48c7a7c03f 100644
--- a/ProcessMaker/Providers/EncryptedDataServiceProvider.php
+++ b/ProcessMaker/Providers/EncryptedDataServiceProvider.php
@@ -5,7 +5,7 @@
 use Illuminate\Support\ServiceProvider;
 use ProcessMaker\Managers\EncryptedDataManager;
 
-class EncryptedDataProvider extends ServiceProvider
+class EncryptedDataServiceProvider extends ServiceProvider
 {
     /**
      * Register services.
diff --git a/ProcessMaker/Repositories/CaseTaskRepository.php b/ProcessMaker/Repositories/CaseTaskRepository.php
index 83caca2a53..653dfff4fd 100644
--- a/ProcessMaker/Repositories/CaseTaskRepository.php
+++ b/ProcessMaker/Repositories/CaseTaskRepository.php
@@ -45,7 +45,7 @@ public function updateCaseParticipatedTaskStatus()
     public function updateTaskStatus()
     {
         try {
-            $case = $this->findCaseByTaskId($this->caseNumber, (string)$this->task->id);
+            $case = $this->findCaseByTaskId($this->caseNumber, (string) $this->task->id);
 
             if (!$case) {
                 Log::error('CaseException: ' . 'Case not found, case_number=' . $this->caseNumber . ', task_id=' . $this->task->id);
@@ -80,7 +80,7 @@ public function findCaseByTaskId(int $caseNumber, string $taskId): ?object
         return DB::table($this->table)
             ->select([
                 'case_number',
-                DB::raw("JSON_UNQUOTE(JSON_SEARCH(tasks, 'one', ?, NULL, '$[*].id')) as task_index")
+                DB::raw("JSON_UNQUOTE(JSON_SEARCH(tasks, 'one', ?, NULL, '$[*].id')) as task_index"),
             ])
             ->where('case_number', $caseNumber)
             ->whereJsonContains('tasks', ['id' => $taskId])
diff --git a/ProcessMaker/Repositories/CaseUtils.php b/ProcessMaker/Repositories/CaseUtils.php
index 552c994e3b..49a48f6ff2 100644
--- a/ProcessMaker/Repositories/CaseUtils.php
+++ b/ProcessMaker/Repositories/CaseUtils.php
@@ -153,7 +153,7 @@ public static function storeTasks(Collection $tasks, ?array $taskData = []): Col
         ) {
             unset($taskData['element_type']);
             // This field is converted to string because: The Json_Search in MySQL only works with strings
-            $taskData['id'] = (string)$taskData['id'];
+            $taskData['id'] = (string) $taskData['id'];
             $tasks->prepend($taskData);
         }
 
diff --git a/ProcessMaker/Repositories/TokenRepository.php b/ProcessMaker/Repositories/TokenRepository.php
index 74a8e79e0b..5f6368c3a4 100644
--- a/ProcessMaker/Repositories/TokenRepository.php
+++ b/ProcessMaker/Repositories/TokenRepository.php
@@ -134,7 +134,7 @@ public function persistActivityActivated(ActivityInterface $activity, TokenInter
                     $dataManager = new DataManager();
                     $tokenData = $dataManager->getData($token);
                     $feel = new FeelExpressionEvaluator();
-                    $evaluatedUsers = $selfServiceUsers ? $feel->render($selfServiceUsers, $tokenData) ?? null: [];
+                    $evaluatedUsers = $selfServiceUsers ? $feel->render($selfServiceUsers, $tokenData) ?? null : [];
                     $evaluatedGroups = $selfServiceGroups ? $feel->render($selfServiceGroups, $tokenData) ?? null : [];
 
                     // If we have single values we put it inside an array
diff --git a/ProcessMaker/Traits/ExtendedPMQL.php b/ProcessMaker/Traits/ExtendedPMQL.php
index 69161bf708..6fcddf950d 100644
--- a/ProcessMaker/Traits/ExtendedPMQL.php
+++ b/ProcessMaker/Traits/ExtendedPMQL.php
@@ -43,7 +43,7 @@ public function useDataStoreTable(Builder $query, string $table, array $map)
      * PMQL scope that extends the standard PMQL scope by supporting any custom
      * aliases specified in the model.
      *
-     * @param \Illuminate\Database\Eloquent\Builder $builder
+     * @param Builder $builder
      * @param string $query
      * @param callable $callback
      *
@@ -92,8 +92,8 @@ private static function getFromExpression($values, $fields)
      * Callback function to check for and handle any field aliases, value
      * aliases, or field wildcards specified in the given model.
      *
-     * @param \ProcessMaker\Query\Expression $expression
-     * @param \Illuminate\Database\Eloquent\Builder $builder
+     * @param Expression $expression
+     * @param Builder $builder
      *
      * @return mixed
      */
@@ -190,7 +190,7 @@ private function handle(Expression $expression, Builder $builder, User $user = n
      * Set the value as a string if possible. Also convert to the logged-in
      * user's timezone if the value is parsable by Carbon as a date.
      *
-     * @param \ProcessMaker\Query\Expression $expression
+     * @param Expression $expression
      *
      * @return mixed
      */
diff --git a/ProcessMaker/Traits/HasScreenFields.php b/ProcessMaker/Traits/HasScreenFields.php
index 4fd7c9bf14..f64dbc79b1 100644
--- a/ProcessMaker/Traits/HasScreenFields.php
+++ b/ProcessMaker/Traits/HasScreenFields.php
@@ -1,16 +1,20 @@
 <?php
+
 namespace ProcessMaker\Traits;
 
 use Illuminate\Support\Arr;
 use Log;
 use ProcessMaker\Models\Column;
 use ProcessMaker\Models\Screen;
+
 trait HasScreenFields
 {
     private $parsedFields;
+
     private $restrictedComponents = [
         'FormImage',
     ];
+
     public function getFieldsAttribute()
     {
         if (empty($this->parsedFields)) {
@@ -31,6 +35,7 @@ public function getFieldsAttribute()
                 ]);
             }
         }
+
         return $this->parsedFields->unique('field');
     }
 
@@ -56,7 +61,6 @@ public function walkArray($array, $key = null)
             $array = json_decode($array);
         }
         foreach ($array as $subkey => $value) {
-
             if (isset($value['component']) && $value['component'] === 'FormNestedScreen') {
                 $this->parseNestedScreen($value);
             } elseif (isset($value['component']) && $value['component'] === 'FormCollectionRecordControl') {
@@ -132,6 +136,7 @@ public function parseItemFormat($item)
                     break;
             }
         }
+
         return $format;
     }
 
@@ -159,7 +164,6 @@ public function parseEncryptedConfig($item)
      *
      * @return array
      */
-
     public function screenFilteredFields()
     {
         return $this->fields->pluck('field');
diff --git a/ProcessMaker/Traits/InteractsWithRawFilter.php b/ProcessMaker/Traits/InteractsWithRawFilter.php
index ef92adec8a..9052f8b03b 100644
--- a/ProcessMaker/Traits/InteractsWithRawFilter.php
+++ b/ProcessMaker/Traits/InteractsWithRawFilter.php
@@ -2,9 +2,9 @@
 
 namespace ProcessMaker\Traits;
 
-use Illuminate\Support\Str;
-use Illuminate\Support\Facades\DB;
 use Illuminate\Contracts\Database\Query\Expression;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
 
 trait InteractsWithRawFilter
 {
@@ -20,7 +20,7 @@ trait InteractsWithRawFilter
     /**
      * Unwrap the raw() and retrieve the string value passed
      *
-     * @return \Illuminate\Contracts\Database\Query\Expression
+     * @return Expression
      */
     public function getRawValue(): Expression
     {
@@ -113,7 +113,7 @@ private function validateOperator(): void
         $allowed = $this->validRawFilterOperators;
 
         if (!in_array($this->operator(), $allowed, true)) {
-            abort(422, 'Invalid operator: Only '.implode(', ', $allowed). ' are allowed.');
+            abort(422, 'Invalid operator: Only ' . implode(', ', $allowed) . ' are allowed.');
         }
     }
 }
diff --git a/ProcessMaker/Traits/PluginServiceProviderTrait.php b/ProcessMaker/Traits/PluginServiceProviderTrait.php
index 2e25a147ec..dcb60f118c 100644
--- a/ProcessMaker/Traits/PluginServiceProviderTrait.php
+++ b/ProcessMaker/Traits/PluginServiceProviderTrait.php
@@ -37,7 +37,7 @@ protected function completePluginBoot()
     /**
      * Executed during modeler starting
      *
-     * @param  \ProcessMaker\Events\ModelerStarting  $event
+     * @param  ModelerStarting  $event
      *
      * @throws \Exception
      */
@@ -164,7 +164,7 @@ public function removePackage($package)
     /**
      * Executed during script builder starting
      *
-     * @param  \ProcessMaker\Events\ScriptBuilderStarting  $event
+     * @param  ScriptBuilderStarting  $event
      *
      * @throws \Exception
      */
diff --git a/ProcessMaker/Traits/TaskScreenResourceTrait.php b/ProcessMaker/Traits/TaskScreenResourceTrait.php
index bf0d97774e..23c245eb87 100644
--- a/ProcessMaker/Traits/TaskScreenResourceTrait.php
+++ b/ProcessMaker/Traits/TaskScreenResourceTrait.php
@@ -4,7 +4,6 @@
 
 trait TaskScreenResourceTrait
 {
-
     /**
      * Removes the inspector metadata from the screen configuration
      *
@@ -16,6 +15,7 @@ private function removeInspectorMetadata(array $config)
         foreach ($config as $i => $page) {
             $config[$i]['items'] = $this->removeInspectorMetadataItems($page['items']);
         }
+
         return $config;
     }
 
@@ -40,6 +40,7 @@ private function removeInspectorMetadataItems(array $items)
             }
             $items[$i] = $item;
         }
+
         return $items;
     }
 }
diff --git a/tests/Feature/Api/V1_1/TaskControllerTest.php b/tests/Feature/Api/V1_1/TaskControllerTest.php
index e93c3836ce..9032362162 100644
--- a/tests/Feature/Api/V1_1/TaskControllerTest.php
+++ b/tests/Feature/Api/V1_1/TaskControllerTest.php
@@ -40,16 +40,47 @@ public function testShowScreen()
             __DIR__ . '/Fixtures/nested_screen_process.json'
         );
         ImportProcess::dispatchSync($content);
+        $process = Process::where('name', 'nested screen test')->first();
         $request = ProcessRequest::factory()->create([
-            'process_id' => Process::where('name', 'nested screen test')->first()->id,
+            'process_id' => $process->id,
         ]);
+        $processVersion = $process->getPublishedVersion([]);
         $task = ProcessRequestToken::factory()->create([
             'element_type' => 'task',
             'element_name' => 'Task 1',
             'element_id' => 'node_2',
-            'process_id' => Process::where('name', 'nested screen test')->first()->id,
+            'process_id' => $process->id,
             'process_request_id' => $request->id,
         ]);
+        $screenVersion = $task->getScreenVersion();
+        $this->assertNotNull($screenVersion, 'Screen version not found');
+
+        // Set up test user
+        Auth::setUser($this->user);
+
+        // Create cache manager mock
+        $screenCache = $this->getMockBuilder(ScreenCacheManager::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        // Set up ScreenCacheFactory to return our mock
+        ScreenCacheFactory::setTestInstance($screenCache);
+
+        // Set up expected cache key parameters
+        $expectedParams = [
+            'process_id' => (int) $process->id,
+            'process_version_id' => (int) $processVersion->id,
+            'language' => $this->user->language,
+            'screen_id' => (int) $screenVersion->screen_id,
+            'screen_version_id' => (int) $screenVersion->id,
+        ];
+
+        // Mock createKey method with array parameter
+        $screenCache->expects($this->once())
+            ->method('createKey')
+            ->with($expectedParams)
+            ->willReturn("pid_{$process->id}_{$processVersion->id}_{$this->user->language}_sid_{$screenVersion->screen_id}_{$screenVersion->id}");
+
         $response = $this->apiCall('GET', route('api.1.1.tasks.show.screen', $task->id) . '?include=screen,nested');
         $this->assertNotNull($response->json());
         $this->assertIsArray($response->json());
@@ -94,29 +125,26 @@ public function testShowScreenCache()
         ScreenCacheFactory::setTestInstance($screenCache);
 
         // Set up expected cache key parameters
-        $processId = $process->id;
-        $processVersionId = $processVersion->id;
-        $language = $this->user->language;
-        $screenId = $screenVersion->screen_id;
-        $screenVersionId = $screenVersion->id;
-        $screenKey = "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+        $expectedParams = [
+            'process_id' => (int) $process->id,
+            'process_version_id' => (int) $processVersion->id,
+            'language' => $this->user->language,
+            'screen_id' => (int) $screenVersion->screen_id,
+            'screen_version_id' => (int) $screenVersion->id,
+        ];
+
+        $screenKey = "pid_{$process->id}_{$processVersion->id}_{$this->user->language}_sid_{$screenVersion->screen_id}_{$screenVersion->id}";
 
         // Mock createKey method
         $screenCache->expects($this->once())
             ->method('createKey')
-            ->with(
-                $processId,
-                $processVersionId,
-                $language,
-                $screenId,
-                $screenVersionId
-            )
+            ->with($expectedParams)
             ->willReturn($screenKey);
 
         // Mock cached content
         $cachedContent = [
-            'id' => $screenId,
-            'screen_version_id' => $screenVersionId,
+            'id' => $screenVersion->screen_id,
+            'screen_version_id' => $screenVersion->id,
             'config' => ['some' => 'config'],
             'watchers' => [],
             'computed' => [],
diff --git a/tests/Feature/Cache/SettingCacheTest.php b/tests/Feature/Cache/SettingCacheTest.php
index 2f34d50784..a1ee312b48 100644
--- a/tests/Feature/Cache/SettingCacheTest.php
+++ b/tests/Feature/Cache/SettingCacheTest.php
@@ -69,9 +69,9 @@ public function testGetSettingByKeyCached(): void
         $this->upgrade();
 
         $key = 'password-policies.users_can_change';
-
+        $cacheKey = 'setting_password-policies.users_can_change';
         $setting = Setting::where('key', $key)->first();
-        \SettingCache::set($key, $setting);
+        \SettingCache::set($cacheKey, $setting);
 
         $this->trackQueries();
 
@@ -260,7 +260,7 @@ public function testClearOnlySettings()
 
     public function testInvalidateOnSaved()
     {
-        $setting  = Setting::factory()->create([
+        $setting = Setting::factory()->create([
             'key' => 'password-policies.users_can_change',
             'config' => 1,
             'format' => 'boolean',
@@ -278,7 +278,7 @@ public function testInvalidateOnSaved()
 
     public function testInvalidateOnDeleted()
     {
-        $setting  = Setting::factory()->create([
+        $setting = Setting::factory()->create([
             'key' => 'password-policies.users_can_change',
             'config' => 1,
             'format' => 'boolean',
@@ -296,7 +296,7 @@ public function testInvalidateOnDeleted()
 
     public function testInvalidateWithException()
     {
-        $setting  = Setting::factory()->create([
+        $setting = Setting::factory()->create([
             'key' => 'password-policies.numbers',
             'config' => 1,
             'format' => 'boolean',
@@ -308,13 +308,16 @@ public function testInvalidateWithException()
         $this->assertEquals(1, $settingCache->config);
 
         \SettingCache::shouldReceive('invalidate')
-            ->with($setting->key)
+            ->with(['key' => $setting->key])
             ->andThrow(new SettingCacheException('Failed to invalidate cache KEY:' . $setting->key))
             ->once();
+        \SettingCache::shouldReceive('clear')
+            ->once()
+            ->andReturn(true);
+
         $this->expectException(SettingCacheException::class);
         $this->expectExceptionMessage('Failed to invalidate cache KEY:' . $setting->key);
-
-        \SettingCache::shouldReceive('clear')->once()->andReturn(true);
+        \SettingCache::invalidate(['key' => $setting->key]);
 
         $setting->delete();
     }
diff --git a/tests/unit/ProcessMaker/Cache/Monitoring/CacheMetricsDecoratorTest.php b/tests/unit/ProcessMaker/Cache/Monitoring/CacheMetricsDecoratorTest.php
index 324f19def7..718137a0ed 100644
--- a/tests/unit/ProcessMaker/Cache/Monitoring/CacheMetricsDecoratorTest.php
+++ b/tests/unit/ProcessMaker/Cache/Monitoring/CacheMetricsDecoratorTest.php
@@ -36,6 +36,11 @@ protected function setUp(): void
     public function testGetWithHit()
     {
         // Setup expectations for cache hit
+        $this->cache->shouldReceive('has')
+            ->once()
+            ->with($this->testKey)
+            ->andReturn(true);
+
         $this->cache->shouldReceive('get')
             ->once()
             ->with($this->testKey, null)
@@ -57,6 +62,11 @@ public function testGetWithMiss()
         $default = 'default_value';
 
         // Setup expectations for cache miss
+        $this->cache->shouldReceive('has')
+            ->once()
+            ->with($this->testKey)
+            ->andReturn(false);
+
         $this->cache->shouldReceive('get')
             ->once()
             ->with($this->testKey, $default)
@@ -223,11 +233,23 @@ public function testCreateKey()
         // Setup expectations
         $this->cache->shouldReceive('createKey')
             ->once()
-            ->with(1, 2, 'en', 3, 4)
+            ->with([
+                'process_id' => 1,
+                'process_version_id' => 2,
+                'language' => 'en',
+                'screen_id' => 3,
+                'screen_version_id' => 4,
+            ])
             ->andReturn('screen_1_2_en_3_4');
 
         // Execute and verify
-        $key = $this->decorator->createKey(1, 2, 'en', 3, 4);
+        $key = $this->decorator->createKey([
+            'process_id' => 1,
+            'process_version_id' => 2,
+            'language' => 'en',
+            'screen_id' => 3,
+            'screen_version_id' => 4,
+        ]);
         $this->assertEquals('screen_1_2_en_3_4', $key);
     }
 
@@ -235,61 +257,73 @@ public function testCreateKeyWithNonScreenCache()
     {
         // Create a mock that only implements CacheInterface
         $cache = Mockery::mock(CacheInterface::class);
+        $cache->shouldReceive('createKey')
+            ->once()
+            ->andThrow(new \BadMethodCallException('Method Mockery_0_ProcessMaker_Cache_CacheInterface::createKey() does not exist on this mock object'));
+
         $metrics = Mockery::mock(CacheMetricsInterface::class);
         $decorator = new CacheMetricsDecorator($cache, $metrics);
 
-        $this->expectException(\RuntimeException::class);
-        $this->expectExceptionMessage('Underlying cache implementation does not support createKey method');
+        $this->expectException(\BadMethodCallException::class);
+        $this->expectExceptionMessage('Method Mockery_0_ProcessMaker_Cache_CacheInterface::createKey() does not exist on this mock object');
 
-        $decorator->createKey(1, 2, 'en', 3, 4);
+        $decorator->createKey([
+            'process_id' => 1,
+            'process_version_id' => 2,
+            'language' => 'en',
+            'screen_id' => 3,
+            'screen_version_id' => 4,
+        ]);
     }
 
     public function testInvalidateSuccess()
     {
         // Test parameters
-        $screenId = 5;
-        $language = 'es';
+        $params = ['screen_id' => 5, 'language' => 'es'];
 
         // Setup expectations for invalidate
         $this->cache->shouldReceive('invalidate')
             ->once()
-            ->with($screenId, $language)
+            ->with($params)
             ->andReturn(true);
 
         // Execute and verify
-        $result = $this->decorator->invalidate($screenId, $language);
-        $this->assertTrue($result);
+        $result = $this->decorator->invalidate($params);
+        $this->assertNull($result);
     }
 
     public function testInvalidateFailure()
     {
         // Test parameters
-        $screenId = 5;
-        $language = 'es';
+        $params = ['screen_id' => 5, 'language' => 'es'];
 
         // Setup expectations for invalidate to fail
         $this->cache->shouldReceive('invalidate')
             ->once()
-            ->with($screenId, $language)
-            ->andReturn(false);
+            ->with($params)
+            ->andReturnNull();
 
         // Execute and verify
-        $result = $this->decorator->invalidate($screenId, $language);
-        $this->assertFalse($result);
+        $result = $this->decorator->invalidate($params);
+        $this->assertNull($result);
     }
 
     public function testInvalidateWithNonScreenCache()
     {
-        // Create a mock that only implements CacheInterface
+        // Create a mock that implements CacheInterface
         $cache = Mockery::mock(CacheInterface::class);
+        $cache->shouldReceive('invalidate')
+            ->once()
+            ->andThrow(new \BadMethodCallException('Call to undefined method Mock_CacheInterface_27913466::invalidate()'));
+
         $metrics = Mockery::mock(CacheMetricsInterface::class);
         $decorator = new CacheMetricsDecorator($cache, $metrics);
 
-        $this->expectException(\RuntimeException::class);
-        $this->expectExceptionMessage('Underlying cache implementation does not support invalidate method');
+        $this->expectException(\BadMethodCallException::class);
+        $this->expectExceptionMessage('Call to undefined method Mock_CacheInterface_27913466::invalidate()');
 
-        // Execute with any parameters since it should throw before using them
-        $decorator->invalidate(5, 'es');
+        // Execute with test parameters
+        $decorator->invalidate(['screen_id' => 5, 'language' => 'es']);
     }
 
     protected function tearDown(): void
diff --git a/tests/unit/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapterTest.php b/tests/unit/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapterTest.php
index 1a00443314..e9861869d3 100644
--- a/tests/unit/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapterTest.php
+++ b/tests/unit/ProcessMaker/Cache/Screens/LegacyScreenCacheAdapterTest.php
@@ -29,11 +29,32 @@ public function it_creates_correct_cache_key()
             ->with('1', '2', 'en', '3', '4')
             ->andReturn('pid_1_2_en_sid_3_4');
 
-        $key = $this->adapter->createKey(1, 2, 'en', 3, 4);
+        $key = $this->adapter->createKey([
+            'process_id' => 1,
+            'process_version_id' => 2,
+            'language' => 'en',
+            'screen_id' => 3,
+            'screen_version_id' => 4,
+        ]);
 
         $this->assertEquals('pid_1_2_en_sid_3_4', $key);
     }
 
+    /** @test */
+    public function it_throws_exception_when_missing_required_parameters()
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Missing required parameters for screen cache key');
+
+        $this->adapter->createKey([
+            'process_id' => 1,
+            // Missing process_version_id
+            'language' => 'en',
+            'screen_id' => 3,
+            'screen_version_id' => 4,
+        ]);
+    }
+
     /** @test */
     public function it_gets_content_from_compiled_manager()
     {
@@ -126,8 +147,8 @@ public function testInvalidateSuccess()
             ->andReturn(true);
 
         // Execute and verify
-        $result = $this->adapter->invalidate($screenId, $language);
-        $this->assertTrue($result);
+        $result = $this->adapter->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     /** @test */
@@ -144,8 +165,8 @@ public function testInvalidateFailure()
             ->andReturn(false);
 
         // Execute and verify
-        $result = $this->adapter->invalidate($screenId, $language);
-        $this->assertFalse($result);
+        $result = $this->adapter->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     /** @test */
@@ -162,8 +183,8 @@ public function testInvalidateWithSpecialLanguageCode()
             ->andReturn(true);
 
         // Execute and verify
-        $result = $this->adapter->invalidate($screenId, $language);
-        $this->assertTrue($result);
+        $result = $this->adapter->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     /** @test */
@@ -180,8 +201,8 @@ public function testInvalidateWithEmptyResults()
             ->andReturn(false);
 
         // Execute and verify
-        $result = $this->adapter->invalidate($screenId, $language);
-        $this->assertFalse($result);
+        $result = $this->adapter->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     protected function tearDown(): void
diff --git a/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheFactoryTest.php b/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheFactoryTest.php
index 1ca7691f8c..aa930cea40 100644
--- a/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheFactoryTest.php
+++ b/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheFactoryTest.php
@@ -2,12 +2,13 @@
 
 namespace Tests\Unit\ProcessMaker\Cache\Screens;
 
+use Illuminate\Cache\CacheManager;
 use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\CacheInterface;
 use ProcessMaker\Cache\Monitoring\CacheMetricsDecorator;
 use ProcessMaker\Cache\Monitoring\RedisMetricsManager;
 use ProcessMaker\Cache\Screens\LegacyScreenCacheAdapter;
 use ProcessMaker\Cache\Screens\ScreenCacheFactory;
-use ProcessMaker\Cache\Screens\ScreenCacheInterface;
 use ProcessMaker\Cache\Screens\ScreenCacheManager;
 use ProcessMaker\Managers\ScreenCompiledManager;
 use Tests\TestCase;
@@ -32,7 +33,7 @@ public function testCreateNewCacheManager()
         $mockManager = $this->createMock(ScreenCacheManager::class);
         $this->app->instance(ScreenCacheManager::class, $mockManager);
 
-        $cache = ScreenCacheFactory::create();
+        $cache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
 
         // Should be wrapped with metrics decorator
         $this->assertInstanceOf(CacheMetricsDecorator::class, $cache);
@@ -51,7 +52,7 @@ public function testCreateLegacyCacheAdapter()
     {
         Config::set('screens.cache.manager', 'legacy');
 
-        $cache = ScreenCacheFactory::create();
+        $cache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
 
         // Should be wrapped with metrics decorator
         $this->assertInstanceOf(CacheMetricsDecorator::class, $cache);
@@ -75,12 +76,12 @@ public function testMetricsIntegrationWithBothAdapters()
         $mockManager = $this->createMock(ScreenCacheManager::class);
         $this->app->instance(ScreenCacheManager::class, $mockManager);
 
-        $newCache = ScreenCacheFactory::create();
+        $newCache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
         $this->verifyMetricsDecorator($newCache, ScreenCacheManager::class);
 
         // Test with legacy adapter
         Config::set('screens.cache.manager', 'legacy');
-        $legacyCache = ScreenCacheFactory::create();
+        $legacyCache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
         $this->verifyMetricsDecorator($legacyCache, LegacyScreenCacheAdapter::class);
     }
 
@@ -116,15 +117,18 @@ public function testInvalidateWithNewCacheManager()
         $mockManager = $this->createMock(ScreenCacheManager::class);
         $mockManager->expects($this->once())
             ->method('invalidate')
-            ->with(5, 'es')
-            ->willReturn(true);
+            ->with(['screen_id' => 5, 'language' => 'es']);
 
         $this->app->instance(ScreenCacheManager::class, $mockManager);
 
-        $cache = ScreenCacheFactory::create();
-        $result = $cache->invalidate(5, 'es');
+        $cache = ScreenCacheFactory::create(
+            app('cache'),
+            app(RedisMetricsManager::class)
+        );
 
-        $this->assertTrue($result);
+        $cache->invalidate(['screen_id' => 5, 'language' => 'es']);
+
+        // No assertion needed since we verified the method was called with expects()
     }
 
     /**
@@ -140,15 +144,15 @@ public function testInvalidateWithLegacyCache()
         $mockCompiledManager = $this->createMock(ScreenCompiledManager::class);
         $mockCompiledManager->expects($this->once())
             ->method('deleteScreenCompiledContent')
-            ->with('5', 'es')
+            ->with(5, 'es')
             ->willReturn(true);
 
         $this->app->instance(ScreenCompiledManager::class, $mockCompiledManager);
 
-        $cache = ScreenCacheFactory::create();
-        $result = $cache->invalidate(5, 'es');
+        $cache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
+        $result = $cache->invalidate(['screen_id' => 5, 'language' => 'es']);
 
-        $this->assertTrue($result);
+        $this->assertNull($result);
     }
 
     /**
@@ -159,7 +163,7 @@ public function testInvalidateWithLegacyCache()
     public function testGetScreenCacheReturnsSameInstanceAsCreate()
     {
         // Get instances using both methods
-        $instance1 = ScreenCacheFactory::create();
+        $instance1 = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
         $instance2 = ScreenCacheFactory::getScreenCache();
 
         // Verify they are the same type and have same metrics wrapper
@@ -186,13 +190,13 @@ public function testGetScreenCacheReturnsSameInstanceAsCreate()
     public function testFactoryRespectsTestInstance()
     {
         // Create a mock for ScreenCacheInterface
-        $mockInterface = $this->createMock(ScreenCacheInterface::class);
+        $mockInterface = $this->createMock(CacheInterface::class);
 
         // Set the test instance in the factory
         ScreenCacheFactory::setTestInstance($mockInterface);
 
         // Retrieve the instance from the factory
-        $instance = ScreenCacheFactory::create();
+        $instance = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
 
         // Assert that the instance is the mock we set
         $this->assertSame($mockInterface, $instance);
@@ -211,7 +215,7 @@ public function testMetricsDecorationIsAppliedCorrectly()
         foreach ($cacheTypes as $type) {
             Config::set('screens.cache.manager', $type);
 
-            $cache = ScreenCacheFactory::create();
+            $cache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
 
             // Verify outer wrapper is metrics decorator
             $this->assertInstanceOf(CacheMetricsDecorator::class, $cache);
@@ -236,7 +240,7 @@ public function testFactoryWithInvalidConfiguration()
         Config::set('screens.cache.manager', 'invalid');
 
         // Should default to legacy cache
-        $cache = ScreenCacheFactory::create();
+        $cache = ScreenCacheFactory::create(app('cache'), app(RedisMetricsManager::class));
 
         $reflection = new \ReflectionClass(CacheMetricsDecorator::class);
         $property = $reflection->getProperty('cache');
diff --git a/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheManagerTest.php b/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheManagerTest.php
index e88388e942..448753e6b0 100644
--- a/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheManagerTest.php
+++ b/tests/unit/ProcessMaker/Cache/Screens/ScreenCacheManagerTest.php
@@ -46,8 +46,15 @@ public function testCreatesCorrectCacheKey()
         $languages = ['en', 'es', 'fr', 'de'];
 
         foreach ($languages as $lang) {
-            $key = $this->screenCache->createKey(1, 2, $lang, 3, 4);
-            $expectedKey = "pid_1_2_{$lang}_sid_3_4";
+            $params = [
+                'process_id' => 1,
+                'process_version_id' => 2,
+                'language' => $lang,
+                'screen_id' => 3,
+                'screen_version_id' => 4,
+            ];
+            $key = $this->screenCache->createKey($params);
+            $expectedKey = "screen_pid_1_2_{$lang}_sid_3_4";
 
             $this->assertEquals($expectedKey, $key);
         }
@@ -288,8 +295,8 @@ public function testInvalidateSuccess()
             ->andReturn(true);
 
         // Execute and verify
-        $result = $this->screenCache->invalidate($screenId, $language);
-        $this->assertTrue($result);
+        $result = $this->screenCache->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     /** @test */
@@ -311,8 +318,8 @@ public function testInvalidateFailure()
             ->andReturn(false); // Make forget operation fail
 
         // Execute and verify
-        $result = $this->screenCache->invalidate($screenId, $language);
-        $this->assertTrue($result);
+        $result = $this->screenCache->invalidate(['screen_id' => $screenId, 'language' => $language]);
+        $this->assertNull($result);
     }
 
     protected function tearDown(): void