diff --git a/README.md b/README.md
index c847fa4..8e994d8 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,12 @@ For details on how to use the MLC Service and Factory directly.
 
 [MultiLevelCacheService and MultiLevelCacheFactory Documentation](documentation/mlc-service-and-factory.md)
 
+# FAQ
+
+We now have an FAQ with the most common questions on how to do things.
+
+[Look Here for all FAQ goodness](documentation/faq.md)
+
 ## License
 
 MIT
diff --git a/documentation/faq.md b/documentation/faq.md
new file mode 100644
index 0000000..26a2ed4
--- /dev/null
+++ b/documentation/faq.md
@@ -0,0 +1,11 @@
+# FAQ
+
+## I want to:
+
+- [Create a simple Cached Version of a service i have](faq/01_simple_example.md)
+- [Only use the [Redis/In-Memory] cache and not the others](faq/02_configure_the_mlc.md)
+- [Have an additional interface on my Cached Service](faq/03_additional_interface.md)
+
+## That's nice but:
+- [What if the DTO i return changes, doesn't this cause problems?](faq/but_01_data_version.md)
+- [What if my method uses internal properties the MLC doesn't know about?](faq/but_02_additional_cache_key_getter.md)
\ No newline at end of file
diff --git a/documentation/faq/01_simple_example.md b/documentation/faq/01_simple_example.md
new file mode 100644
index 0000000..1eec5df
--- /dev/null
+++ b/documentation/faq/01_simple_example.md
@@ -0,0 +1,93 @@
+# Simple example of a cached service:
+
+Given you have the following Service that you want a cached Version of.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+class TestService
+{
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+## Preparing the source service
+First we need to tell the MLC what methods can be cached and how long to hold the data for.
+
+We do that by adding the `MlcCacheableMethod` attribute to each method we want cached and set the `ttlSeconds` property accordingly.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+## Generating the Cached Version
+
+We now run the `ddev mlc-make App.Service.TestService` command.
+
+```
+$ ddev mlc-make App.Service.TestService
+========================================================
+          Create or Update a cached service...
+========================================================
+
+
+Parsing command line arguments...
+| Argument   | Value                     |
+------------------------------------------
+| service    | App.Service.TestService   |
+
+Resolving service class for 'App.Service.TestService'...
+Service class found: App\Service\TestService
+
+------------------------------------
+     Generating cached service.
+------------------------------------
+
+Use statement for interface 'App\Interface\Service\TestServiceInterface' does not exists in file: /var/www/html/src/Service/TestService.php
+Attempt adding it.
+Added interface 'App\Interface\Service\TestServiceInterface' to class 'App\Service\TestService' in file: /var/www/html/src/Service/TestService.php
+
+Cached service generated successfully.
+
+| Key         | Value                                                          |
+--------------------------------------------------------------------------------
+| Class       | /var/www/html/src/Service/TestServiceCached.php                |
+| Interface   | /var/www/html/src/Interface/Service/TestServiceInterface.php   |
+```
+
+## Using the Service
+
+To use the new Service you can:
+- Swap the `TestService` to `TestServiceCached` to always use the cached version, or
+- Set the Injection to `TestServiceInterface` and configure the dependency injection via your symfony services.yaml
\ No newline at end of file
diff --git a/documentation/faq/02_configure_the_mlc.md b/documentation/faq/02_configure_the_mlc.md
new file mode 100644
index 0000000..a0e6943
--- /dev/null
+++ b/documentation/faq/02_configure_the_mlc.md
@@ -0,0 +1,60 @@
+# Configuring the CSG to use a specific cache configuration
+
+We have this service:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+What we now want to do is add the `MlcCacheableService` attribute to the class and set the `cacheType` property.
+
+For our example we will use `Redis`, but every other option from `CacheTypeEnum` works too.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableService;
+use Tbessenreither\MultiLevelCache\Enum\CacheTypeEnum;
+
+#[MlcCacheableService(cacheType: CacheTypeEnum::REDIS)]
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+Then you update the cached service by running `ddev mlc-update`. (You probably don't need to, but better be save than sorry)
\ No newline at end of file
diff --git a/documentation/faq/03_additional_interface.md b/documentation/faq/03_additional_interface.md
new file mode 100644
index 0000000..44f4547
--- /dev/null
+++ b/documentation/faq/03_additional_interface.md
@@ -0,0 +1,61 @@
+# Adding an additional interface to the cached service
+
+We have this service:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+What we now want to do is add the `MlcCacheableService` attribute to the class and set the `additionalInterface` property.
+
+For our example we will use `SomeGreatInterface`.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Interface\SomeGreatInterface;
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableService;
+use Tbessenreither\MultiLevelCache\Enum\CacheTypeEnum;
+
+#[MlcCacheableService(additionalInterface: SomeGreatInterface::class)]
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+Then you update the cached service by running `ddev mlc-update`.
\ No newline at end of file
diff --git a/documentation/faq/but_01_data_version.md b/documentation/faq/but_01_data_version.md
new file mode 100644
index 0000000..4fbe7b8
--- /dev/null
+++ b/documentation/faq/but_01_data_version.md
@@ -0,0 +1,62 @@
+# Preventing data colissions when a DTO changes
+
+We have this service:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+What we want to do is tell the MLC about the change in Data structure.
+
+We do this by setting the `dataVersion` property of either the `MlcCacheableMethod` or as a default in `MlcCacheableService`. The later will act as the default data version for all cached methods.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+
+    #[MlcCacheableMethod(
+        ttlSeconds: 300,
+        dataVersion: '1',
+    )]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return "something";
+    }
+
+}
+```
+
+The Data Version can be any string. I would recommend starting with 1 and then just counting up every time you change something.
+
+That's it. Now the MLC knows about your DTO changes and can keep the variants separate.
\ No newline at end of file
diff --git a/documentation/faq/but_02_additional_cache_key_getter.md b/documentation/faq/but_02_additional_cache_key_getter.md
new file mode 100644
index 0000000..29a6138
--- /dev/null
+++ b/documentation/faq/but_02_additional_cache_key_getter.md
@@ -0,0 +1,83 @@
+# Exposing internal properties to the MLC for Key generation
+
+The response of the cached method is dependend on some internal state that is not present in the method arguments.
+
+Let's say we have this example:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+class TestService
+{
+    private string $stringToReturn = 'something';
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return $this->stringToReturn;
+    }
+
+    public function setStringToReturn(string $string): void
+    {
+        $this->stringToReturn = $string;
+    }
+
+}
+```
+
+This would cause the MLC to cache the first response and then ignore all changes to `$this->stringToReturn`. That's not good.
+
+Let's fix this by setting the `additionalCacheKeyGetter` property of `MlcCacheableService`.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use Tbessenreither\MultiLevelCache\CachedServiceGenerator\Attribute\MlcCacheableMethod;
+
+#[MlcCacheableService(additionalCacheKeyGetter: 'getAdditionalCacheKeys')]
+class TestService
+{
+    private string $stringToReturn = 'something';
+
+    #[MlcCacheableMethod(ttlSeconds: 300)]
+    public function doSomething(): string
+    {
+        // very expensive operation here, e.g. a call to an external API or a complex calculation
+        sleep(2); // Simulate a delay
+
+        return $this->stringToReturn;
+    }
+
+    public function setStringToReturn(string $string): void
+    {
+        $this->stringToReturn = $string;
+    }
+
+    public function getAdditionalCacheKeys(): array
+    {
+        return [
+            'importantString' => $this->stringToReturn,
+        ];
+    }
+
+}
+```
+
+Now the MLC is aware that there is more to your Service function than the method attributes and everything should work as expected.
+
+Additional Bonus Fact:
+
+You can return any serializable data through the getter. As long as PHPs `serialize()` can handle it, the MLC is fine with it.
\ No newline at end of file
diff --git a/src/CopycatConfig.php b/src/CopycatConfig.php
index fbb11e8..ffe1177 100644
--- a/src/CopycatConfig.php
+++ b/src/CopycatConfig.php
@@ -4,6 +4,7 @@
 
 namespace Tbessenreither\MultiLevelCache;
 
+use Tbessenreither\Copycat\Dto\EnvVar;
 use Tbessenreither\Copycat\Enum\CopyTargetEnum;
 use Tbessenreither\Copycat\Enum\EnvTargetEnum;
 use Tbessenreither\Copycat\Interface\CopycatConfigInterface;
@@ -33,17 +34,37 @@ public static function run(CopycatInterface $copycat): void
         $copycat->envAdd(
             target: EnvTargetEnum::DOT_EXAMPLE,
             entries: [
-                'REDIS_DSN' => 'redis://redis:6379',
-                'MLC_DISABLE_READ' => 'FLAG_ACTIVE',
-                'MLC_COLLECT_ENHANCED_DATA' => false,
+                new EnvVar(
+                    name: 'REDIS_DSN',
+                    value: 'redis://redis:6379',
+                    description: 'The DSN for the Redis server used by the Multi-Level Cache Bundle.',
+                ),
+                new EnvVar(
+                    name: 'MLC_DISABLE_READ',
+                    isFlag: true,
+                    description: 'When present, the Multi-Level-Cache will not perform cache reads and always call the source, but it will still perform cache writes. This can be useful for testing or debugging purposes.',
+                ),
+                new EnvVar(
+                    name: 'MLC_COLLECT_ENHANCED_DATA',
+                    value: true,
+                    description: 'When true the profiler will collect extra data for statistics and debugging. This will take more time and memory, so it should only be enabled in development environments.',
+                ),
             ],
             overwrite: true,
         );
         $copycat->envAdd(
             target: EnvTargetEnum::DOT_LOCAL,
             entries: [
-                'REDIS_DSN' => 'redis://redis:6379',
-                'MLC_COLLECT_ENHANCED_DATA' => false,
+                new EnvVar(
+                    name: 'REDIS_DSN',
+                    value: 'redis://redis:6379',
+                    description: 'The DSN for the Redis server used by the Multi-Level Cache Bundle.',
+                ),
+                new EnvVar(
+                    name: 'MLC_COLLECT_ENHANCED_DATA',
+                    value: true,
+                    description: 'When true the profiler will collect extra data for statistics and debugging. This will take more time and memory, so it should only be enabled in development environments.',
+                ),
             ],
             overwrite: false,
         );
diff --git a/src/Service/MultiLevelCacheService.php b/src/Service/MultiLevelCacheService.php
index 50c96c7..7a34f1e 100644
--- a/src/Service/MultiLevelCacheService.php
+++ b/src/Service/MultiLevelCacheService.php
@@ -511,10 +511,10 @@ private function cacheReadDisabled(): bool
         return $this->cacheReadDisabled;
     }
 
-    private function cloneBulkMethodCallObjectWithNewIdentifier(MethodCallObject $methodCallObject, string|int $newIdentifier): MethodCallObject
+    private function cloneBulkMethodCallObjectWithNewIdentifier(MethodCallObject $methodCallObject, string|int|float $newIdentifier): MethodCallObject
     {
-        if (is_int($newIdentifier)) {
-            $newIdentifier = (string) $newIdentifier;
+        if (!is_string($newIdentifier)) {
+            $newIdentifier = (string)$newIdentifier;
         }
 
         $arguments = $methodCallObject->getArguments();
diff --git a/tests/CachedServiceGenerator/Service/TestSrc/TestServiceA.php b/tests/CachedServiceGenerator/Service/TestSrc/TestServiceA.php
index 6bb5c04..46cbe86 100644
--- a/tests/CachedServiceGenerator/Service/TestSrc/TestServiceA.php
+++ b/tests/CachedServiceGenerator/Service/TestSrc/TestServiceA.php
@@ -66,6 +66,23 @@ public static function bulkTestFunctionWithIntIdentifier(array $keys)
         return $values;
     }
 
+    public static function bulkTestFunctionWithFloatIdentifier(array $keys)
+    {
+        self::$sourceWasCalled = true;
+        self::$entriesRequestedFromSource = $keys;
+        $values = [];
+        $i = 1;
+        foreach ($keys as $key) {
+            $values[] = [
+                'key' => (float) $i + 0.5,
+                'value' => 'value for ' . $key,
+            ];
+            $i++;
+        }
+
+        return $values;
+    }
+
     public static function bulkTestFunctionWithWrongResponse(array $keys)
     {
         $response = [];
diff --git a/tests/Dto/DataCollectorIssueDtoTest.php b/tests/Dto/DataCollectorIssueDtoTest.php
index 29218f1..5be0631 100644
--- a/tests/Dto/DataCollectorIssueDtoTest.php
+++ b/tests/Dto/DataCollectorIssueDtoTest.php
@@ -15,7 +15,7 @@
 #[CoversClass(DataCollectorIssueDto::class)]
 #[UsesClass(WarningEnum::class)]
 #[UsesClass(DataCollectorIssueOccurrenceDto::class)]
-
+#[UsesClass(InfoEnum::class)]
 class DataCollectorIssueDtoTest extends TestCase
 {
     public function testGettersAndSetters(): void
diff --git a/tests/Service/MultiLevelCacheServiceTest.php b/tests/Service/MultiLevelCacheServiceTest.php
index 1bd9c19..c8982c2 100644
--- a/tests/Service/MultiLevelCacheServiceTest.php
+++ b/tests/Service/MultiLevelCacheServiceTest.php
@@ -534,6 +534,52 @@ class: TestServiceA::class,
         $this->assertEquals($expectedResults, $results, 'The results from the getBulk callable should match the expected results');
     }
 
+    public function testGetBulkWithFloatIdentifier(): void
+    {
+        $keys = ['key1', 'key2', 'key3'];
+        $expectedResults = [];
+        $i = 1;
+        foreach ($keys as $key) {
+            $id = $i;
+            $expectedResults[] = [
+                'key' => (float) $id + 0.5,
+                'value' => 'value for ' . $key,
+            ];
+            $i++;
+        }
+        TestServiceA::resetStatic();
+        $methodCallObject = new MethodCallObject(
+            class: TestServiceA::class,
+            method: 'bulkTestFunctionWithFloatIdentifier',
+            arguments: [$keys],
+        );
+
+
+        $service = new MultiLevelCacheService(
+            caches: [new InMemoryCacheService(5)],
+            writeL0OnSet: true,
+            stopwatch: null,
+            cacheDataCollector: null,
+            ttlRandomnessSeconds: 0,
+        );
+
+        $results = $service->getBulk(
+            methodCallObject: $methodCallObject,
+            mlcCacheableMethodAttribute: new MlcCacheableMethod(
+                ttlSeconds: 5,
+                bulkConfig: new BulkConfig(
+                    identifierSelector: 'key',
+                    listType: BulkListTypeEnum::ARRAY_NUMERIC,
+                ),
+            ),
+        );
+
+        $this->assertTrue(TestServiceA::$sourceWasCalled, 'The source callable should have been called since bulk is not configured');
+        $this->assertEquals($keys, TestServiceA::$entriesRequestedFromSource, 'The keys requested from the source should match the original keys');
+
+        $this->assertEquals($expectedResults, $results, 'The results from the getBulk callable should match the expected results');
+    }
+
     public function testGetBulkMisconfigured(): void
     {
         $keys = ['key1', 'key2', 'key3'];
@@ -743,6 +789,18 @@ public function testConstructorHelperSetupDataCollector(): void
         $this->assertIsArray($statisticsObject->getConfigData(), 'The config data in the statistics object should be an array');
     }
 
+    public function testExceptionTransparencyRuntimeException(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $service = new MultiLevelCacheService(
+            caches: [new InMemoryCacheService(5)],
+        );
+
+        $service->get('testkey', function () {
+            throw new RuntimeException('Test exception');
+        }, 300);
+    }
+
     private function fixYieldedConfiguration(array &$configuration)
     {
         $caches = [];