diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5d4d0cb18..aca092db4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,8 +16,6 @@ jobs:
     strategy:
       matrix:
         include:
-        - laravel: "^9.0"
-          php: "8.0"
         - laravel: "^10.0"
           php: "8.2"
 
diff --git a/assets/config.php b/assets/config.php
index 7fc6c9289..3875aca15 100644
--- a/assets/config.php
+++ b/assets/config.php
@@ -2,6 +2,7 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\CacheManager;
 use Stancl\Tenancy\Middleware;
 use Stancl\Tenancy\Resolvers;
 
@@ -98,10 +99,10 @@
      */
     'bootstrappers' => [
         Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper::class,
-        Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\BatchTenancyBootstrapper::class,
+        // Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\UrlTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\SessionTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\MailTenancyBootstrapper::class, // Queueing mail requires using QueueTenancyBootstrapper with $forceRefresh set to true
@@ -178,7 +179,7 @@
     ],
 
     /**
-     * Cache tenancy config. Used by CacheTenancyBootstrapper.
+     * Cache tenancy config. Used by the custom CacheManager and the PrefixCacheTenancyBootstrapper.
      *
      * This works for all Cache facade calls, cache() helper
      * calls and direct calls to injected cache stores.
@@ -190,6 +191,7 @@
      */
     'cache' => [
         'tag_base' => 'tenant', // This tag_base, followed by the tenant_id, will form a tag that will be applied on each cache call.
+        'prefix_base' => 'tenant_', // This prefix_base, followed by the tenant_id, will form a cache prefix that will be used for every cache key.
     ],
 
     /**
diff --git a/composer.json b/composer.json
index 528829053..cadd9ee50 100644
--- a/composer.json
+++ b/composer.json
@@ -17,7 +17,7 @@
     "require": {
         "php": "^8.2",
         "ext-json": "*",
-        "illuminate/support": "^9.38|^10.0",
+        "illuminate/support": "^10.1",
         "facade/ignition-contracts": "^1.0.2",
         "spatie/ignition": "^1.4",
         "ramsey/uuid": "^4.7.3",
@@ -26,8 +26,8 @@
         "spatie/invade": "^1.1"
     },
     "require-dev": {
-        "laravel/framework": "^9.38|^10.0",
-        "orchestra/testbench": "^7.0|^8.0",
+        "laravel/framework": "^10.1",
+        "orchestra/testbench": "^8.0",
         "league/flysystem-aws-s3-v3": "^3.12.2",
         "doctrine/dbal": "^3.6.0",
         "spatie/valuestore": "^1.2.5",
diff --git a/src/Bootstrappers/CacheTenancyBootstrapper.php b/src/Bootstrappers/CacheTagsBootstrapper.php
similarity index 67%
rename from src/Bootstrappers/CacheTenancyBootstrapper.php
rename to src/Bootstrappers/CacheTagsBootstrapper.php
index 29547faea..7ab28c960 100644
--- a/src/Bootstrappers/CacheTenancyBootstrapper.php
+++ b/src/Bootstrappers/CacheTagsBootstrapper.php
@@ -7,13 +7,20 @@
 use Illuminate\Cache\CacheManager;
 use Illuminate\Contracts\Foundation\Application;
 use Illuminate\Support\Facades\Cache;
-use Stancl\Tenancy\CacheManager as TenantCacheManager;
 use Stancl\Tenancy\Contracts\TenancyBootstrapper;
 use Stancl\Tenancy\Contracts\Tenant;
 
-class CacheTenancyBootstrapper implements TenancyBootstrapper
+/**
+ * todo name.
+ *
+ * Separate tenant cache using tagging.
+ * This is the legacy approach. Some things, like dependency injection, won't work properly with this bootstrapper.
+ * PrefixCacheTenancyBootstrapper is the recommended bootstrapper for cache separation.
+ */
+class CacheTagsBootstrapper implements TenancyBootstrapper
 {
     protected ?CacheManager $originalCache = null;
+    public static string $cacheManagerWithTags = \Stancl\Tenancy\CacheManager::class;
 
     public function __construct(
         protected Application $app
@@ -24,9 +31,9 @@ public function bootstrap(Tenant $tenant): void
     {
         $this->resetFacadeCache();
 
-        $this->originalCache = $this->originalCache ?? $this->app['cache'];
+        $this->originalCache ??= $this->app['cache'];
         $this->app->extend('cache', function () {
-            return new TenantCacheManager($this->app);
+            return new static::$cacheManagerWithTags($this->app);
         });
     }
 
diff --git a/src/Bootstrappers/PrefixCacheTenancyBootstrapper.php b/src/Bootstrappers/PrefixCacheTenancyBootstrapper.php
new file mode 100644
index 000000000..ad0ea6f4a
--- /dev/null
+++ b/src/Bootstrappers/PrefixCacheTenancyBootstrapper.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Bootstrappers;
+
+use Closure;
+use Illuminate\Cache\CacheManager;
+use Illuminate\Cache\Repository;
+use Illuminate\Contracts\Config\Repository as ConfigRepository;
+use Illuminate\Support\Facades\Cache;
+use Stancl\Tenancy\Contracts\TenancyBootstrapper;
+use Stancl\Tenancy\Contracts\Tenant;
+
+class PrefixCacheTenancyBootstrapper implements TenancyBootstrapper
+{
+    protected string|null $originalPrefix = null;
+    public static array $tenantCacheStores = []; // E.g. ['redis']
+    public static Closure|null $prefixGenerator = null;
+
+    public function __construct(
+        protected ConfigRepository $config,
+        protected CacheManager $cacheManager,
+    ) {
+    }
+
+    public function bootstrap(Tenant $tenant): void
+    {
+        $this->originalPrefix = $this->config->get('cache.prefix');
+
+        $prefix = $this->generatePrefix($tenant);
+
+        foreach (static::$tenantCacheStores as $store) {
+            $this->setCachePrefix($store, $prefix);
+
+            // Now that the store uses the passed prefix
+            // Set the configured prefix back to the default one
+            $this->config->set('cache.prefix', $this->originalPrefix);
+        }
+    }
+
+    public function revert(): void
+    {
+        foreach (static::$tenantCacheStores as $store) {
+            $this->setCachePrefix($store, $this->originalPrefix);
+        }
+    }
+
+    protected function setCachePrefix(string $driver, string|null $prefix): void
+    {
+        $this->config->set('cache.prefix', $prefix);
+
+        // Refresh driver's store to make the driver use the current prefix
+        $this->refreshStore($driver);
+
+        // It is needed when a call to the facade has been made before bootstrapping tenancy
+        // The facade has its own cache, separate from the container
+        Cache::clearResolvedInstances();
+    }
+
+    public function generatePrefix(Tenant $tenant): string
+    {
+        $defaultPrefix = $this->originalPrefix . $this->config->get('tenancy.cache.prefix_base') . $tenant->getTenantKey();
+
+        return static::$prefixGenerator ? (static::$prefixGenerator)($tenant) : $defaultPrefix;
+    }
+
+    public static function generatePrefixUsing(Closure $prefixGenerator): void
+    {
+        static::$prefixGenerator = $prefixGenerator;
+    }
+
+    /**
+     * Refresh cache driver's store.
+     */
+    protected function refreshStore(string $driver): void
+    {
+        $newStore = $this->cacheManager->resolve($driver)->getStore();
+        /** @var Repository $repository */
+        $repository = $this->cacheManager->driver($driver);
+
+        $repository->setStore($newStore);
+    }
+}
diff --git a/tests/BootstrapperTest.php b/tests/BootstrapperTest.php
index 7350f0a8b..9260c9c9b 100644
--- a/tests/BootstrapperTest.php
+++ b/tests/BootstrapperTest.php
@@ -28,18 +28,26 @@
 use Stancl\Tenancy\Tests\Etc\TestingBroadcaster;
 use Stancl\Tenancy\Listeners\DeleteTenantStorage;
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
 use Stancl\Tenancy\Bootstrappers\UrlTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\MailTenancyBootstrapper;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper;
 use Stancl\Tenancy\Middleware\InitializeTenancyBySubdomain;
 use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\BroadcastTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 
 beforeEach(function () {
     $this->mockConsoleOutput = false;
 
+    config(['cache.default' => $cacheDriver = 'redis']);
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver];
+    // Reset static properties of classes used in this test file to their default values
+    BroadcastTenancyBootstrapper::$credentialsMap = [];
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+    UrlTenancyBootstrapper::$rootUrlOverride = null;
+
     Event::listen(
         TenantCreated::class,
         JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
@@ -51,6 +59,14 @@
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    // Reset static properties of classes used in this test file to their default values
+    UrlTenancyBootstrapper::$rootUrlOverride = null;
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+    BroadcastTenancyBootstrapper::$credentialsMap = [];
+});
+
 test('database data is separated', function () {
     config(['tenancy.bootstrappers' => [
         DatabaseTenancyBootstrapper::class,
@@ -82,12 +98,9 @@
     expect(DB::table('users')->first()->name)->toBe('Foo');
 });
 
-test('cache data is separated', function () {
+test('cache data is separated', function (string $bootstrapper) {
     config([
-        'tenancy.bootstrappers' => [
-            CacheTenancyBootstrapper::class,
-        ],
-        'cache.default' => 'redis',
+        'tenancy.bootstrappers' => [$bootstrapper],
     ]);
 
     $tenant1 = Tenant::create();
@@ -121,7 +134,10 @@
 
     // Asset central is still the same
     expect(Cache::get('foo'))->toBe('central');
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);
 
 test('redis data is separated', function () {
     config(['tenancy.bootstrappers' => [
diff --git a/tests/BroadcastingTest.php b/tests/BroadcastingTest.php
index aeb70de26..9505b5378 100644
--- a/tests/BroadcastingTest.php
+++ b/tests/BroadcastingTest.php
@@ -13,12 +13,17 @@
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
 use Illuminate\Contracts\Broadcasting\Broadcaster as BroadcasterContract;
 
-beforeEach(function() {
+beforeEach(function () {
     withTenantDatabases();
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+});
+
 test('bound broadcaster instance is the same before initializing tenancy and after ending it', function() {
     config(['broadcasting.default' => 'null']);
     TenancyBroadcastManager::$tenantBroadcasters[] = 'null';
diff --git a/tests/CacheManagerTest.php b/tests/CacheManagerTest.php
index 03580fe12..744d81d20 100644
--- a/tests/CacheManagerTest.php
+++ b/tests/CacheManagerTest.php
@@ -2,16 +2,14 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Event;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Listeners\BootstrapTenancy;
-use Stancl\Tenancy\Tests\Etc\Tenant;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
 
 beforeEach(function () {
-    config(['tenancy.bootstrappers' => [
-        CacheTenancyBootstrapper::class,
-    ]]);
+    config(['tenancy.bootstrappers' => [CacheTagsBootstrapper::class]]);
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
 });
@@ -60,7 +58,7 @@
     $tenant2 = Tenant::create();
     tenancy()->initialize($tenant2);
 
-    pest()->assertNotSame('bar', cache()->get('foo'));
+    expect(cache('foo'))->not()->toBe('bar');
 
     cache()->put('foo', 'xyz', 1);
     expect(cache()->get('foo'))->toBe('xyz');
@@ -76,7 +74,7 @@
     $tenant2 = Tenant::create();
     tenancy()->initialize($tenant2);
 
-    pest()->assertNotSame('bar', cache('foo'));
+    expect(cache('foo'))->not()->toBe('bar');
 
     cache(['foo' => 'xyz'], 1);
     expect(cache('foo'))->toBe('xyz');
diff --git a/tests/DomainTest.php b/tests/DomainTest.php
index 024599144..cb1045327 100644
--- a/tests/DomainTest.php
+++ b/tests/DomainTest.php
@@ -12,6 +12,8 @@
 use Stancl\Tenancy\Resolvers\DomainTenantResolver;
 
 beforeEach(function () {
+    InitializeTenancyByDomain::$onFail = null;
+
     Route::group([
         'middleware' => InitializeTenancyByDomain::class,
     ], function () {
@@ -23,6 +25,10 @@
     config(['tenancy.models.tenant' => DomainTenant::class]);
 });
 
+afterEach(function () {
+    InitializeTenancyByDomain::$onFail = null;
+});
+
 test('tenant can be identified using hostname', function () {
     $tenant = DomainTenant::create();
 
@@ -89,9 +95,6 @@
 });
 
 test('throw correct exception when onFail is null and universal routes are enabled', function () {
-    // un-define onFail logic
-    InitializeTenancyByDomain::$onFail = null;
-
     // Enable UniversalRoute feature
     Route::middlewareGroup('universal', []);
 
diff --git a/tests/Etc/CacheService.php b/tests/Etc/CacheService.php
new file mode 100644
index 000000000..c228d59ed
--- /dev/null
+++ b/tests/Etc/CacheService.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Tests\Etc;
+
+use Illuminate\Cache\Repository;
+
+class CacheService
+{
+    public function __construct(
+       protected Repository $cache
+    ) {
+    }
+
+    public function handle(): void
+    {
+        if (tenancy()->initialized) {
+            $this->cache->put('key', tenant()->getTenantKey());
+        } else {
+            $this->cache->put('key', 'central-value');
+        }
+    }
+}
diff --git a/tests/Etc/SpecificCacheStoreService.php b/tests/Etc/SpecificCacheStoreService.php
new file mode 100644
index 000000000..579e2caa4
--- /dev/null
+++ b/tests/Etc/SpecificCacheStoreService.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Tests\Etc;
+
+use Illuminate\Cache\CacheManager;
+use Illuminate\Cache\Repository;
+
+class SpecificCacheStoreService
+{
+    public Repository $cache;
+
+    public function __construct(CacheManager $cacheManager, string $cacheStoreName)
+    {
+        $this->cache = $cacheManager->store($cacheStoreName);
+    }
+
+    public function handle(): void
+    {
+        if (tenancy()->initialized) {
+            $this->cache->put('key', tenant()->getTenantKey());
+        } else {
+            $this->cache->put('key', 'central-value');
+        }
+    }
+}
diff --git a/tests/GlobalCacheTest.php b/tests/GlobalCacheTest.php
index ea38341b1..22fc2641f 100644
--- a/tests/GlobalCacheTest.php
+++ b/tests/GlobalCacheTest.php
@@ -2,25 +2,32 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\CacheManager;
+use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Event;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Events\TenancyEnded;
-use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Facades\GlobalCache;
+use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Listeners\BootstrapTenancy;
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
-use Stancl\Tenancy\Tests\Etc\Tenant;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 
 beforeEach(function () {
-    config(['tenancy.bootstrappers' => [
-        CacheTenancyBootstrapper::class,
-    ]]);
+    config(['cache.default' => $cacheDriver = 'redis']);
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver];
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
-test('global cache manager stores data in global cache', function () {
+afterEach(function () {
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+});
+
+test('global cache manager stores data in global cache', function (string $bootstrapper) {
+    config(['tenancy.bootstrappers' => [$bootstrapper]]);
+
     expect(cache('foo'))->toBe(null);
     GlobalCache::put(['foo' => 'bar'], 1);
     expect(GlobalCache::get('foo'))->toBe('bar');
@@ -48,9 +55,14 @@
 
     tenancy()->initialize($tenant1);
     expect(cache('def'))->toBe('ghi');
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);
+
+test('the global_cache helper supports the same syntax as the cache helper', function (string $bootstrapper) {
+    config(['tenancy.bootstrappers' => [$bootstrapper]]);
 
-test('the global_cache helper supports the same syntax as the cache helper', function () {
     $tenant = Tenant::create();
     $tenant->enter();
 
@@ -63,4 +75,7 @@
     expect(global_cache()->get('foo'))->toBe('baz');
 
     expect(cache('foo'))->toBe(null); // tenant cache is not affected
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);
diff --git a/tests/MailTest.php b/tests/MailTest.php
index c530b7e8c..dc48648a6 100644
--- a/tests/MailTest.php
+++ b/tests/MailTest.php
@@ -12,11 +12,16 @@
 
 beforeEach(function() {
     config(['mail.default' => 'smtp']);
+    MailTenancyBootstrapper::$credentialsMap = [];
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    MailTenancyBootstrapper::$credentialsMap = [];
+});
+
 // Initialize tenancy as $tenant and assert that the smtp mailer's transport has the correct password
 function assertMailerTransportUsesPassword(string|null $password) {
     $manager = app(MailManager::class);
diff --git a/tests/PrefixCacheBootstrapperTest.php b/tests/PrefixCacheBootstrapperTest.php
new file mode 100644
index 000000000..68a9d33c4
--- /dev/null
+++ b/tests/PrefixCacheBootstrapperTest.php
@@ -0,0 +1,324 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Cache\CacheManager;
+use Illuminate\Support\Facades\Event;
+use Stancl\Tenancy\Events\TenancyEnded;
+use Stancl\Tenancy\Tests\Etc\CacheService;
+use Stancl\Tenancy\Events\TenancyInitialized;
+use Stancl\Tenancy\Listeners\BootstrapTenancy;
+use Stancl\Tenancy\Listeners\RevertToCentralContext;
+use Stancl\Tenancy\Tests\Etc\SpecificCacheStoreService;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
+
+beforeEach(function () {
+    config([
+        'tenancy.bootstrappers' => [
+            PrefixCacheTenancyBootstrapper::class
+        ],
+        'cache.default' => $cacheDriver = 'redis',
+        'cache.stores.' . $secondCacheDriver = 'redis2' => config('cache.stores.redis'),
+    ]);
+
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver, $secondCacheDriver];
+    PrefixCacheTenancyBootstrapper::$prefixGenerator = null;
+
+    Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
+    Event::listen(TenancyEnded::class, RevertToCentralContext::class);
+});
+
+afterEach(function () {
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+    PrefixCacheTenancyBootstrapper::$prefixGenerator = null;
+});
+
+test('correct cache prefix is used in all contexts', function () {
+    $originalPrefix = config('cache.prefix');
+    $prefixBase = config('tenancy.cache.prefix_base');
+    $getDefaultPrefixForTenant = fn (Tenant $tenant) => $originalPrefix . $prefixBase . $tenant->getTenantKey();
+    $bootstrapper = app(PrefixCacheTenancyBootstrapper::class);
+
+    $expectCachePrefixToBe = function (string $prefix) {
+        expect($prefix . ':') // RedisStore suffixes prefix with ':'
+            ->toBe(app('cache')->getPrefix())
+            ->toBe(app('cache.store')->getPrefix())
+            ->toBe(cache()->getPrefix())
+            ->toBe(cache()->store('redis2')->getPrefix()); // Non-default cache stores specified in $tenantCacheStores are prefixed too
+    };
+
+    $expectCachePrefixToBe($originalPrefix);
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+    cache()->set('key', 'tenantone-value');
+    $tenantOnePrefix = $getDefaultPrefixForTenant($tenant1);
+    $expectCachePrefixToBe($tenantOnePrefix);
+    expect($bootstrapper->generatePrefix($tenant1))->toBe($tenantOnePrefix);
+
+    tenancy()->initialize($tenant2);
+    cache()->set('key', 'tenanttwo-value');
+    $tenantTwoPrefix = $getDefaultPrefixForTenant($tenant2);
+    $expectCachePrefixToBe($tenantTwoPrefix);
+    expect($bootstrapper->generatePrefix($tenant2))->toBe($tenantTwoPrefix);
+
+    // Prefix gets reverted to default after ending tenancy
+    tenancy()->end();
+    $expectCachePrefixToBe($originalPrefix);
+
+    // Assert tenant's data is accessible using the prefix from the central context
+    config(['cache.prefix' => null]); // stop prefixing cache keys in central so we can provide prefix manually
+    app('cache')->forgetDriver(config('cache.default'));
+
+    expect(cache($tenantOnePrefix . ':key'))->toBe('tenantone-value');
+    expect(cache($tenantTwoPrefix . ':key'))->toBe('tenanttwo-value');
+});
+
+test('cache is persisted when reidentification is used', function () {
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache(['foo' => 'bar']);
+    expect(cache('foo'))->toBe('bar');
+
+    tenancy()->initialize($tenant2);
+    expect(cache('foo'))->toBeNull();
+    tenancy()->end();
+
+    tenancy()->initialize($tenant1);
+    expect(cache('foo'))->toBe('bar');
+});
+
+test('prefixing separates the cache', function () {
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache()->put('foo', 'bar');
+    expect(cache()->get('foo'))->toBe('bar');
+
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant2);
+
+    expect(cache()->get('foo'))->toBeNull();
+
+    cache()->put('foo', 'xyz');
+    expect(cache()->get('foo'))->toBe('xyz');
+
+    tenancy()->initialize($tenant1);
+    expect(cache()->get('foo'))->toBe('bar');
+});
+
+test('central cache is persisted', function () {
+    cache()->put('key', 'central');
+
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    cache()->put('key', 'tenant');
+
+    expect(cache()->get('key'))->toBe('tenant');
+
+    tenancy()->end();
+    cache()->put('key2', 'central-two');
+
+    expect(cache()->get('key'))->toBe('central');
+    expect(cache()->get('key2'))->toBe('central-two');
+    
+    tenancy()->initialize($tenant1);
+    expect(cache()->get('key'))->toBe('tenant');
+    expect(cache()->get('key2'))->toBeNull();
+});
+
+test('cache base prefix is customizable', function () {
+    config([
+        'tenancy.cache.prefix_base' => $prefixBase = 'custom_'
+    ]);
+
+    $originalPrefix = config('cache.prefix');
+    $tenant1 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+
+    expect($originalPrefix . $prefixBase . $tenant1->getTenantKey() . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()) // Non-default store gets prefixed correctly too
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+});
+
+test('cache is prefixed correctly when using a repository injected in a singleton', function () {
+    $this->app->singleton(CacheService::class);
+
+    expect(cache('key'))->toBeNull();
+
+    $this->app->make(CacheService::class)->handle();
+
+    expect(cache('key'))->toBe('central-value');
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant1->getTenantKey());
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant2->getTenantKey());
+
+    tenancy()->end();
+
+    expect(cache('key'))->toBe('central-value');
+});
+
+test('specific central cache store can be used inside a service', function () {
+    // Make sure 'redis' (the default store) is the only prefixed store
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = ['redis'];
+    // Name of the non-default, central cache store that we'll use using cache()->store($cacheStore)
+    $cacheStore = 'redis2';
+
+    // Service uses the 'redis2' store which is central/not prefixed (not present in PrefixCacheTenancyBootstrapper::$tenantCacheStores)
+    // The service's handle() method sets the value of the cache key 'key' to the current tenant key
+    // Or to 'central-value' if tenancy isn't initialized
+    $this->app->singleton(SpecificCacheStoreService::class, function() use ($cacheStore) {
+        return new SpecificCacheStoreService($this->app->make(CacheManager::class), $cacheStore);
+    });
+
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe('central-value');
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    // The store isn't prefixed, so the cache isn't separated – the values persist from one context to another
+    // Also assert that the value of 'key' is set correctly inside SpecificCacheStoreService according to the current context
+    expect(cache()->store($cacheStore)->get('key'))->toBe('central-value');
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant1->getTenantKey());
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant1->getTenantKey());
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant2->getTenantKey());
+
+    tenancy()->end();
+    // We last executed handle() in tenant2's context, so the value should persist as tenant2's id
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant2->getTenantKey());
+});
+
+test('only the stores specified in tenantCacheStores get prefixed', function () {
+    // Make sure the currently used store ('redis') is the only store in $tenantCacheStores
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$prefixedStore = 'redis'];
+
+    $centralValue = 'central-value';
+    $assertStoreIsNotPrefixed = function (string $unprefixedStore) use ($prefixedStore, $centralValue) {
+        // Switch to the unprefixed store
+        config(['cache.default' => $unprefixedStore]);
+        expect(cache('key'))->toBe($centralValue);
+        // Switch back to the prefixed store
+        config(['cache.default' => $prefixedStore]);
+    };
+
+    $this->app->singleton(CacheService::class);
+
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($centralValue);
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant1->getTenantKey());
+
+    $assertStoreIsNotPrefixed('redis2');
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant2->getTenantKey());
+
+    $assertStoreIsNotPrefixed('redis2');
+
+    tenancy()->end();
+    expect(cache('key'))->toBe($centralValue);
+
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($centralValue);
+});
+
+test('non default stores get prefixed too when specified in tenantCacheStores', function () {
+    // In beforeEach, we set $tenantCacheStores to ['redis', 'redis2']
+    // Make 'redis' the default cache driver
+    config(['cache.default' => 'redis']);
+
+    $tenant = Tenant::create();
+    $defaultPrefix = cache()->store()->getPrefix();
+    $bootstrapper = app(PrefixCacheTenancyBootstrapper::class);
+
+    // The prefix is the same for both drivers in the central context
+    expect(cache()->store('redis')->getPrefix())->toBe($defaultPrefix);
+    expect(cache()->store('redis2')->getPrefix())->toBe($defaultPrefix);
+
+    tenancy()->initialize($tenant);
+
+    // We didn't add a prefix generator for our 'redis2' driver, so we expect the prefix to be generated using the 'default' generator
+    expect($bootstrapper->generatePrefix($tenant) . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()); // Non-default store
+
+    tenancy()->end();
+});
+
+test('cache store prefix generation can be customized', function() {
+    // Use custom prefix generator
+    PrefixCacheTenancyBootstrapper::generatePrefixUsing($customPrefixGenerator = function (Tenant $tenant) {
+        return 'redis_tenant_cache_' . $tenant->getTenantKey();
+    });
+
+    expect(PrefixCacheTenancyBootstrapper::$prefixGenerator)->toBe($customPrefixGenerator);
+    expect(app(PrefixCacheTenancyBootstrapper::class)->generatePrefix($tenant = Tenant::create()))
+        ->toBe($customPrefixGenerator($tenant));
+
+    tenancy()->initialize($tenant = Tenant::create());
+
+    // Expect the 'redis' store to use the prefix generated by the custom generator
+    expect($customPrefixGenerator($tenant) . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()) // Non-default cache stores specified in $tenantCacheStores are prefixed too
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+
+    tenancy()->end();
+});
+
+test('stores get prefixed using the default way if no prefix generator is specified', function() {
+    $originalPrefix = config('cache.prefix');
+    $prefixBase = config('tenancy.cache.prefix_base');
+    $tenant = Tenant::create();
+    $defaultPrefix = $originalPrefix . $prefixBase . $tenant->getTenantKey();
+
+    // Don't specify a prefix generator
+    // Let the prefix get created using the default approach
+    tenancy()->initialize($tenant);
+
+    // All stores use the default way of generating the prefix when the prefix generator isn't specified
+    expect($defaultPrefix . ':')
+        ->toBe(app(PrefixCacheTenancyBootstrapper::class)->generatePrefix($tenant) . ':')
+        ->toBe(cache()->getPrefix()) // Get prefix of the default store ('redis')
+        ->toBe(cache()->store('redis2')->getPrefix());
+
+    tenancy()->end();
+});
diff --git a/tests/TestCase.php b/tests/TestCase.php
index 20ecdfee5..36d5fc9f5 100644
--- a/tests/TestCase.php
+++ b/tests/TestCase.php
@@ -9,6 +9,7 @@
 use Stancl\Tenancy\Facades\Tenancy;
 use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Redis;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 use Illuminate\Foundation\Application;
 use Stancl\Tenancy\Facades\GlobalCache;
 use Stancl\Tenancy\TenancyServiceProvider;
@@ -118,6 +119,7 @@ protected function getEnvironmentSetUp($app)
         ]);
 
         $app->singleton(RedisTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
+        $app->singleton(PrefixCacheTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
         $app->singleton(BroadcastTenancyBootstrapper::class);
         $app->singleton(MailTenancyBootstrapper::class);
         $app->singleton(UrlTenancyBootstrapper::class);