diff --git a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
index df8db79db0..ad7e44c2ae 100644
--- a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
+++ b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
@@ -214,7 +214,6 @@ namespace AZ
                 // Update old Project path before attempting to merge in new Settings Registry values in order to prevent recursive calls
                 m_oldProjectPath = newProjectPath;
 
-                // Merge the project.json file into settings registry under ProjectSettingsRootKey path.
                 // Update all the runtime file paths based on the new "project_path" value.
                 AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(m_registry);
             }
diff --git a/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp b/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp
index 5458a3fadf..3668ab14fd 100644
--- a/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp
+++ b/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp
@@ -29,6 +29,8 @@
 
 namespace AZ::Internal
 {
+    static constexpr const char* ProductCacheDirectoryName = "Cache";
+
     AZ::SettingsRegistryInterface::FixedValueString GetEngineMonikerForProject(
         SettingsRegistryInterface& settingsRegistry, const AZ::IO::FixedMaxPath& projectJsonPath)
     {
@@ -228,19 +230,20 @@ namespace AZ::Internal
 
 namespace AZ::SettingsRegistryMergeUtils
 {
-    constexpr AZStd::string_view InternalScanUpEngineRootKey{ "/O3DE/Settings/Internal/engine_root_scan_up_path" };
-    constexpr AZStd::string_view InternalScanUpProjectRootKey{ "/O3DE/Settings/Internal/project_root_scan_up_path" };
-
     AZ::IO::FixedMaxPath FindEngineRoot(SettingsRegistryInterface& settingsRegistry)
     {
+        static constexpr AZStd::string_view InternalScanUpEngineRootKey{ "/O3DE/Runtime/Internal/engine_root_scan_up_path" };
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+        using Type = SettingsRegistryInterface::Type;
+
         AZ::IO::FixedMaxPath engineRoot;
         // This is the 'external' engine root key, as in passed from command-line or .setreg files.
-        auto engineRootKey = SettingsRegistryInterface::FixedValueString::format("%s/engine_path", BootstrapSettingsRootKey);
+        constexpr auto engineRootKey = FixedValueString(BootstrapSettingsRootKey) + "/engine_path";
 
         // Step 1 Run the scan upwards logic once to find the location of the engine.json if it exist
         // Once this step is run the {InternalScanUpEngineRootKey} is set in the Settings Registry
         // to have this scan logic only run once InternalScanUpEngineRootKey the supplied registry
-        if (settingsRegistry.GetType(InternalScanUpEngineRootKey) == SettingsRegistryInterface::Type::NoType)
+        if (settingsRegistry.GetType(InternalScanUpEngineRootKey) == Type::NoType)
         {
             // We can scan up from exe directory to find engine.json, use that for engine root if it exists.
             engineRoot = Internal::ScanUpRootLocator("engine.json");
@@ -283,14 +286,18 @@ namespace AZ::SettingsRegistryMergeUtils
 
     AZ::IO::FixedMaxPath FindProjectRoot(SettingsRegistryInterface& settingsRegistry)
     {
-        AZ::IO::FixedMaxPath projectRoot;
-        const auto projectRootKey = SettingsRegistryInterface::FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
+        static constexpr AZStd::string_view InternalScanUpProjectRootKey{ "/O3DE/Runtime/Internal/project_root_scan_up_path" };
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+        using Type = SettingsRegistryInterface::Type;
 
-        // Step 1 Run the scan upwards logic once to find the location of the project.json if it exist
+        AZ::IO::FixedMaxPath projectRoot;
+        constexpr auto projectRootKey = FixedValueString(BootstrapSettingsRootKey) + "/project_path";
+
+        // Step 1 Run the scan upwards logic once to find the location of the closest ancestor project.json
         // Once this step is run the {InternalScanUpProjectRootKey} is set in the Settings Registry
         // to have this scan logic only run once for the supplied registry
         // SettingsRegistryInterface::GetType is used to check if a key is set
-        if (settingsRegistry.GetType(InternalScanUpProjectRootKey) == SettingsRegistryInterface::Type::NoType)
+        if (settingsRegistry.GetType(InternalScanUpProjectRootKey) == Type::NoType)
         {
             projectRoot = Internal::ScanUpRootLocator("project.json");
             // Set the {InternalScanUpProjectRootKey} to make sure this code path isn't called again for this settings registry
@@ -305,19 +312,129 @@ namespace AZ::SettingsRegistryMergeUtils
         }
 
         // Step 2 Check the project-path key
-        // This is the project path root key, as in passed from command-line or .setreg files.
-        if (settingsRegistry.Get(projectRoot.Native(), projectRootKey))
+        // This is the project path root key, as passed from command-line or *.setreg files.
+        settingsRegistry.Get(projectRoot.Native(), projectRootKey);
+        return projectRoot;
+    }
+
+    //! The algorithm that is used to find the project cache is as follows
+    //! 1. The "{BootstrapSettingsRootKey}/project_cache_path" is checked for the path
+    //! 2. Otherwise append the ProductCacheDirectoryName constant to the <project-path>
+    static AZ::IO::FixedMaxPath FindProjectCachePath(SettingsRegistryInterface& settingsRegistry, const AZ::IO::FixedMaxPath& projectPath)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+
+        constexpr auto projectCachePathKey = FixedValueString(BootstrapSettingsRootKey) + "/project_cache_path";
+
+        // Step 1 Check the project-cache-path key
+        if (AZ::IO::FixedMaxPath projectCachePath; settingsRegistry.Get(projectCachePath.Native(), projectCachePathKey))
         {
-            return projectRoot;
+            return projectCachePath;
         }
 
-        // Step 3 Check for a "Cache" directory by scanning upwards from the executable directory
-        if (auto candidateRoot = Internal::ScanUpRootLocator("Cache");
-            !candidateRoot.empty() && AZ::IO::SystemFile::IsDirectory(candidateRoot.c_str()))
+        // Step 2 Append the "Cache" directory to the project-path
+        return projectPath / Internal::ProductCacheDirectoryName;
+    }
+
+    //! Set the user directory with the provided path or using <project-path>/user as default
+    static AZ::IO::FixedMaxPath FindProjectUserPath(SettingsRegistryInterface& settingsRegistry,
+        const AZ::IO::FixedMaxPath& projectPath)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+
+        // User: root - same as the @user@ alias, this is the starting path for transient data and log files.
+        constexpr auto projectUserPathKey = FixedValueString(BootstrapSettingsRootKey) + "/project_user_path";
+
+        // Step 1 Check the project-user-path key
+        if (AZ::IO::FixedMaxPath projectUserPath; settingsRegistry.Get(projectUserPath.Native(), projectUserPathKey))
         {
-            projectRoot = AZStd::move(candidateRoot);
+            return projectUserPath;
+        }
+
+        // Step 2 Append the "User" directory to the project-path
+        return projectPath / "user";
+    }
+
+    //! Set the log directory using the settings registry path or using <project-user-path>/log as default
+    static AZ::IO::FixedMaxPath FindProjectLogPath(SettingsRegistryInterface& settingsRegistry,
+        const AZ::IO::FixedMaxPath& projectUserPath)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+
+        // User: root - same as the @log@ alias, this is the starting path for transient data and log files.
+        constexpr auto projectLogPathKey = FixedValueString(BootstrapSettingsRootKey) + "/project_log_path";
+
+        // Step 1 Check the project-user-path key
+        if (AZ::IO::FixedMaxPath projectLogPath; settingsRegistry.Get(projectLogPath.Native(), projectLogPathKey))
+        {
+            return projectLogPath;
+        }
+
+        // Step 2 Append the "Log" directory to the project-user-path
+        return projectUserPath / "log";
+    }
+
+    // check for a default write storage path, fall back to the <project-user-path> if not
+    static AZ::IO::FixedMaxPath FindDevWriteStoragePath(const AZ::IO::FixedMaxPath& projectUserPath)
+    {
+        AZStd::optional<AZ::IO::FixedMaxPathString> devWriteStorage = Utils::GetDevWriteStoragePath();
+        return devWriteStorage.has_value() ? *devWriteStorage : projectUserPath;
+    }
+
+    // check for the project build path, which is a relative path from the project root
+    // that specifies where the build directory is located
+    static void SetProjectBuildPath(SettingsRegistryInterface& settingsRegistry,
+        const AZ::IO::FixedMaxPath& projectPath)
+    {
+        if (AZ::IO::FixedMaxPath projectBuildPath; settingsRegistry.Get(projectBuildPath.Native(), ProjectBuildPath))
+        {
+            settingsRegistry.Remove(FilePathKey_ProjectBuildPath);
+            settingsRegistry.Remove(FilePathKey_ProjectConfigurationBinPath);
+            AZ::IO::FixedMaxPath buildConfigurationPath = (projectPath / projectBuildPath).LexicallyNormal();
+            if (IO::SystemFile::Exists(buildConfigurationPath.c_str()))
+            {
+                settingsRegistry.Set(FilePathKey_ProjectBuildPath, buildConfigurationPath.Native());
+            }
+
+            // Add the specific build configuration paths to the Settings Registry
+            // First try <project-build-path>/bin/$<CONFIG> and if that path doesn't exist
+            // try <project-build-path>/bin/$<PLATFORM>/$<CONFIG>
+            buildConfigurationPath /= "bin";
+            if (IO::SystemFile::Exists((buildConfigurationPath / AZ_BUILD_CONFIGURATION_TYPE).c_str()))
+            {
+                settingsRegistry.Set(FilePathKey_ProjectConfigurationBinPath,
+                    (buildConfigurationPath / AZ_BUILD_CONFIGURATION_TYPE).Native());
+            }
+            else if (IO::SystemFile::Exists((buildConfigurationPath / AZ_TRAIT_OS_PLATFORM_CODENAME / AZ_BUILD_CONFIGURATION_TYPE).c_str()))
+            {
+                settingsRegistry.Set(FilePathKey_ProjectConfigurationBinPath,
+                    (buildConfigurationPath / AZ_TRAIT_OS_PLATFORM_CODENAME / AZ_BUILD_CONFIGURATION_TYPE).Native());
+            }
+        }
+    }
+
+    // Sets the project name within the Settings Registry by looking up the "project_name"
+    // within the project.json file
+    static void SetProjectName(SettingsRegistryInterface& settingsRegistry,
+        const AZ::IO::FixedMaxPath& projectPath)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+        // Project name - if it was set via merging project.json use that value, otherwise use the project path's folder name.
+        constexpr auto projectNameKey = FixedValueString(ProjectSettingsRootKey) + "/project_name";
+
+        // Read the project name from the project.json file if it exists
+        if (AZ::IO::FixedMaxPath projectJsonPath = projectPath / "project.json";
+            AZ::IO::SystemFile::Exists(projectJsonPath.c_str()))
+        {
+            settingsRegistry.MergeSettingsFile(projectJsonPath.Native(),
+                AZ::SettingsRegistryInterface::Format::JsonMergePatch, AZ::SettingsRegistryMergeUtils::ProjectSettingsRootKey);
+        }
+        // If a project name isn't set the default will be set to the final path segment of the project path
+        if (FixedValueString projectName; !settingsRegistry.Get(projectName, projectNameKey))
+        {
+            projectName = projectPath.Filename().Native();
+            settingsRegistry.Set(projectNameKey, projectName);
         }
-        return projectRoot;
     }
 
     AZStd::string_view ConfigParserSettings::DefaultCommentPrefixFilter(AZStd::string_view line)
@@ -397,7 +514,7 @@ namespace AZ::SettingsRegistryMergeUtils
     bool MergeSettingsToRegistry_ConfigFile(SettingsRegistryInterface& registry, AZStd::string_view filePath,
         const ConfigParserSettings& configParserSettings)
     {
-        auto configPath = FindEngineRoot(registry) / filePath;
+        auto configPath = FindProjectRoot(registry) / filePath;
         IO::FileReader configFile;
         bool configFileOpened{};
         switch (configParserSettings.m_fileReaderClass)
@@ -542,19 +659,77 @@ namespace AZ::SettingsRegistryMergeUtils
     void MergeSettingsToRegistry_AddRuntimeFilePaths(SettingsRegistryInterface& registry)
     {
         using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
-        // Binary folder
-        AZ::IO::FixedMaxPath path = AZ::Utils::GetExecutableDirectory();
-        registry.Set(FilePathKey_BinaryFolder, path.LexicallyNormal().Native());
 
-        // Engine root folder - corresponds to the @engroot@ and @engroot@ aliases
-        AZ::IO::FixedMaxPath engineRoot = FindEngineRoot(registry);
-        registry.Set(FilePathKey_EngineRootFolder, engineRoot.LexicallyNormal().Native());
+        // Binary folder - corresponds to the @exefolder@ alias
+        AZ::IO::FixedMaxPath exePath = AZ::Utils::GetExecutableDirectory();
+        registry.Set(FilePathKey_BinaryFolder, exePath.LexicallyNormal().Native());
 
-        auto projectPathKey = FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
-        SettingsRegistryInterface::FixedValueString projectPathValue;
-        if (registry.Get(projectPathValue, projectPathKey))
+        // Project path - corresponds to the @projectroot@ alias
+        // NOTE: We make the project-path in the BootstrapSettingsRootKey absolute first
+
+        AZ::IO::FixedMaxPath projectPath = FindProjectRoot(registry);
+        if (constexpr auto projectPathKey = FixedValueString(BootstrapSettingsRootKey) + "/project_path";
+            !projectPath.empty())
         {
-            // Cache folder
+            if (projectPath.IsRelative())
+            {
+                if (auto projectAbsPath = AZ::Utils::ConvertToAbsolutePath(projectPath.Native());
+                    projectAbsPath.has_value())
+                {
+                    projectPath = AZStd::move(*projectAbsPath);
+                }
+            }
+
+            projectPath = projectPath.LexicallyNormal();
+            AZ_Warning("SettingsRegistryMergeUtils", AZ::IO::SystemFile::Exists(projectPath.c_str()),
+                R"(Project path "%s" does not exist. Is the "%.*s" registry setting set to a valid absolute path?)"
+                , projectPath.c_str(), AZ_STRING_ARG(projectPathKey));
+
+            registry.Set(FilePathKey_ProjectPath, projectPath.Native());
+        }
+        else
+        {
+            AZ_TracePrintf("SettingsRegistryMergeUtils",
+                R"(Project path isn't set in the Settings Registry at "%.*s".)"
+                " Project-related filepaths will be set relative to the executable directory\n",
+                AZ_STRING_ARG(projectPathKey));
+            registry.Set(FilePathKey_ProjectPath, exePath.Native());
+        }
+
+        // Engine root folder - corresponds to the @engroot@ alias
+        AZ::IO::FixedMaxPath engineRoot = FindEngineRoot(registry);
+        if (!engineRoot.empty())
+        {
+            if (engineRoot.IsRelative())
+            {
+                if (auto engineRootAbsPath = AZ::Utils::ConvertToAbsolutePath(engineRoot.Native());
+                    engineRootAbsPath.has_value())
+                {
+                    engineRoot = AZStd::move(*engineRootAbsPath);
+                }
+            }
+
+            engineRoot = engineRoot.LexicallyNormal();
+            registry.Set(FilePathKey_EngineRootFolder, engineRoot.Native());
+        }
+
+        // Cache folder
+        AZ::IO::FixedMaxPath projectCachePath = FindProjectCachePath(registry, projectPath).LexicallyNormal();
+        if (!projectCachePath.empty())
+        {
+            if (projectCachePath.IsRelative())
+            {
+                if (auto projectCacheAbsPath = AZ::Utils::ConvertToAbsolutePath(projectCachePath.Native());
+                    projectCacheAbsPath.has_value())
+                {
+                    projectCachePath = AZStd::move(*projectCacheAbsPath);
+                }
+            }
+
+            projectCachePath = projectCachePath.LexicallyNormal();
+            registry.Set(FilePathKey_CacheProjectRootFolder, projectCachePath.Native());
+
+            // Cache/<asset-platform> folder
             // Get the name of the asset platform assigned by the bootstrap. First check for platform version such as "windows_assets"
             // and if that's missing just get "assets".
             FixedValueString assetPlatform;
@@ -570,124 +745,67 @@ namespace AZ::SettingsRegistryMergeUtils
                 assetPlatform = AZ::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
             }
 
-            // Project path - corresponds to the @projectroot@ alias
-            // NOTE: Here we append to engineRoot, but if projectPathValue is absolute then engineRoot is discarded.
-            path = engineRoot / projectPathValue;
-
-            AZ_Warning("SettingsRegistryMergeUtils", AZ::IO::SystemFile::Exists(path.c_str()),
-                R"(Project path "%s" does not exist. Is the "%.*s" registry setting set to valid absolute path?)"
-                , path.c_str(), aznumeric_cast<int>(projectPathKey.size()), projectPathKey.data());
-
-            AZ::IO::FixedMaxPath normalizedProjectPath = path.LexicallyNormal();
-            registry.Set(FilePathKey_ProjectPath, normalizedProjectPath.Native());
-
-            // Set the user directory with the provided path or using project/user as default
-            auto projectUserPathKey = FixedValueString::format("%s/project_user_path", BootstrapSettingsRootKey);
-            AZ::IO::FixedMaxPath projectUserPath;
-            if (!registry.Get(projectUserPath.Native(), projectUserPathKey))
-            {
-                projectUserPath = (normalizedProjectPath / "user").LexicallyNormal();
-            }
-            registry.Set(FilePathKey_ProjectUserPath, projectUserPath.Native());
-
-            // Set the log directory with the provided path or using project/user/log as default
-            auto projectLogPathKey = FixedValueString::format("%s/project_log_path", BootstrapSettingsRootKey);
-            AZ::IO::FixedMaxPath projectLogPath;
-            if (!registry.Get(projectLogPath.Native(), projectLogPathKey))
-            {
-                projectLogPath = (projectUserPath / "log").LexicallyNormal();
-            }
-            registry.Set(FilePathKey_ProjectLogPath, projectLogPath.Native());
-
-            // check for a default write storage path, fall back to the project's user/ directory if not
-            AZStd::optional<AZ::IO::FixedMaxPathString> devWriteStorage = Utils::GetDevWriteStoragePath();
-            registry.Set(FilePathKey_DevWriteStorage, devWriteStorage.has_value()
-                ? devWriteStorage.value()
-                : projectUserPath.Native());
-
-            // Set the project in-memory build path if the ProjectBuildPath key has been supplied
-            if (AZ::IO::FixedMaxPath projectBuildPath; registry.Get(projectBuildPath.Native(), ProjectBuildPath))
-            {
-                registry.Remove(FilePathKey_ProjectBuildPath);
-                registry.Remove(FilePathKey_ProjectConfigurationBinPath);
-                AZ::IO::FixedMaxPath buildConfigurationPath = normalizedProjectPath / projectBuildPath;
-                if (IO::SystemFile::Exists(buildConfigurationPath.c_str()))
-                {
-                    registry.Set(FilePathKey_ProjectBuildPath, buildConfigurationPath.LexicallyNormal().Native());
-                }
-
-                // Add the specific build configuration paths to the Settings Registry
-                // First try <project-build-path>/bin/$<CONFIG> and if that path doesn't exist
-                // try <project-build-path>/bin/$<PLATFORM>/$<CONFIG>
-                buildConfigurationPath /= "bin";
-                if (IO::SystemFile::Exists((buildConfigurationPath / AZ_BUILD_CONFIGURATION_TYPE).c_str()))
-                {
-                    registry.Set(FilePathKey_ProjectConfigurationBinPath,
-                        (buildConfigurationPath / AZ_BUILD_CONFIGURATION_TYPE).LexicallyNormal().Native());
-                }
-                else if (IO::SystemFile::Exists((buildConfigurationPath / AZ_TRAIT_OS_PLATFORM_CODENAME / AZ_BUILD_CONFIGURATION_TYPE).c_str()))
-                {
-                    registry.Set(FilePathKey_ProjectConfigurationBinPath,
-                        (buildConfigurationPath / AZ_TRAIT_OS_PLATFORM_CODENAME / AZ_BUILD_CONFIGURATION_TYPE).LexicallyNormal().Native());
-                }
-
-            }
-
-            // Project name - if it was set via merging project.json use that value, otherwise use the project path's folder name.
-            constexpr auto projectNameKey =
-                FixedValueString(AZ::SettingsRegistryMergeUtils::ProjectSettingsRootKey)
-                + "/project_name";
-
-            // Read the project name from the project.json file if it exists
-            if (AZ::IO::FixedMaxPath projectJsonPath = normalizedProjectPath / "project.json";
-                AZ::IO::SystemFile::Exists(projectJsonPath.c_str()))
-            {
-                registry.MergeSettingsFile(projectJsonPath.Native(),
-                    AZ::SettingsRegistryInterface::Format::JsonMergePatch, AZ::SettingsRegistryMergeUtils::ProjectSettingsRootKey);
-            }
-            if (FixedValueString projectName; !registry.Get(projectName, projectNameKey))
-            {
-                projectName = path.Filename().Native();
-                registry.Set(projectNameKey, projectName);
-            }
-
-            // Cache folders - sets up various paths in registry for the cache.
-            // Make sure the asset platform is set before setting these cache paths.
+            // Make sure the asset platform is set before setting cache path for the asset platform.
             if (!assetPlatform.empty())
             {
-                // Cache: project root - no corresponding fileIO alias, but this is where the asset database lives.
-                // A registry override is accepted using the "project_cache_path" key.
-                auto projectCacheRootOverrideKey = FixedValueString::format("%s/project_cache_path", BootstrapSettingsRootKey);
-                // Clear path to make sure that the `project_cache_path` value isn't concatenated to the project path
-                path.clear();
-                if (registry.Get(path.Native(), projectCacheRootOverrideKey))
-                {
-                    registry.Set(FilePathKey_CacheProjectRootFolder, path.LexicallyNormal().Native());
-                    path /= assetPlatform;
-                    registry.Set(FilePathKey_CacheRootFolder, path.LexicallyNormal().Native());
-                }
-                else
-                {
-                    // Cache: root - same as the @products@ alias, this is the starting path for cache files.
-                    path = normalizedProjectPath / "Cache";
-                    registry.Set(FilePathKey_CacheProjectRootFolder, path.LexicallyNormal().Native());
-                    path /= assetPlatform;
-                    registry.Set(FilePathKey_CacheRootFolder, path.LexicallyNormal().Native());
-                }
+                registry.Set(FilePathKey_CacheRootFolder, (projectCachePath / assetPlatform).Native());
             }
         }
-        else
+
+        // User folder
+        AZ::IO::FixedMaxPath projectUserPath = FindProjectUserPath(registry, projectPath);
+        if (!projectUserPath.empty())
         {
-            // Set the default ProjectUserPath to the <engine-root>/user directory
-            registry.Set(FilePathKey_ProjectUserPath, (engineRoot / "user").LexicallyNormal().Native());
-            AZ_TracePrintf("SettingsRegistryMergeUtils",
-                R"(Project path isn't set in the Settings Registry at "%.*s". Project-related filepaths will not be set)" "\n",
-                aznumeric_cast<int>(projectPathKey.size()), projectPathKey.data());
+            if (projectUserPath.IsRelative())
+            {
+                if (auto projectUserAbsPath = AZ::Utils::ConvertToAbsolutePath(projectUserPath.Native());
+                    projectUserAbsPath.has_value())
+                {
+                    projectUserPath = AZStd::move(*projectUserAbsPath);
+                }
+            }
+
+            projectUserPath = projectUserPath.LexicallyNormal();
+            registry.Set(FilePathKey_ProjectUserPath, projectUserPath.Native());
         }
 
+        // Log folder
+        if (AZ::IO::FixedMaxPath projectLogPath = FindProjectLogPath(registry, projectUserPath); !projectLogPath.empty())
+        {
+            if (projectLogPath.IsRelative())
+            {
+                if (auto projectLogAbsPath = AZ::Utils::ConvertToAbsolutePath(projectLogPath.Native()))
+                {
+                    projectLogPath = AZStd::move(*projectLogAbsPath);
+                }
+            }
+
+            projectLogPath = projectLogPath.LexicallyNormal();
+            registry.Set(FilePathKey_ProjectLogPath, projectLogPath.Native());
+        }
+
+        // Developer Write Storage folder
+        if (AZ::IO::FixedMaxPath devWriteStoragePath = FindDevWriteStoragePath(projectUserPath); !devWriteStoragePath.empty())
+        {
+            if (devWriteStoragePath.IsRelative())
+            {
+                if (auto devWriteStorageAbsPath = AZ::Utils::ConvertToAbsolutePath(devWriteStoragePath.Native()))
+                {
+                    devWriteStoragePath = AZStd::move(*devWriteStorageAbsPath);
+                }
+            }
+
+            devWriteStoragePath = devWriteStoragePath.LexicallyNormal();
+            registry.Set(FilePathKey_DevWriteStorage, devWriteStoragePath.Native());
+        }
+
+        // Set the project in-memory build path if the ProjectBuildPath key has been supplied
+        SetProjectBuildPath(registry, projectPath);
+        // Set the project name using the "project_name" key
+        SetProjectName(registry, projectPath);
+
 #if !AZ_TRAIT_OS_IS_HOST_OS_PLATFORM
         // Setup the cache, user, and log paths to platform specific locations when running on non-host platforms
-        path = engineRoot;
         if (AZStd::optional<AZ::IO::FixedMaxPathString> nonHostCacheRoot = Utils::GetDefaultAppRootPath();
             nonHostCacheRoot)
         {
@@ -696,25 +814,25 @@ namespace AZ::SettingsRegistryMergeUtils
         }
         else
         {
-            registry.Set(FilePathKey_CacheProjectRootFolder, path.LexicallyNormal().Native());
-            registry.Set(FilePathKey_CacheRootFolder, path.LexicallyNormal().Native());
+            registry.Set(FilePathKey_CacheProjectRootFolder, projectPath.Native());
+            registry.Set(FilePathKey_CacheRootFolder, projectPath.Native());
         }
         if (AZStd::optional<AZ::IO::FixedMaxPathString> devWriteStorage = Utils::GetDevWriteStoragePath();
             devWriteStorage)
         {
-            const AZ::IO::FixedMaxPath devWriteStoragePath(*devWriteStorage);
-            registry.Set(FilePathKey_DevWriteStorage, devWriteStoragePath.LexicallyNormal().Native());
-            registry.Set(FilePathKey_ProjectUserPath, (devWriteStoragePath / "user").LexicallyNormal().Native());
-            registry.Set(FilePathKey_ProjectLogPath, (devWriteStoragePath / "user/log").LexicallyNormal().Native());
+            const auto devWriteStoragePath = AZ::IO::PathView(*devWriteStorage).LexicallyNormal();
+            registry.Set(FilePathKey_DevWriteStorage, devWriteStoragePath.Native());
+            registry.Set(FilePathKey_ProjectUserPath, (devWriteStoragePath / "user").Native());
+            registry.Set(FilePathKey_ProjectLogPath, (devWriteStoragePath / "user" / "log").Native());
         }
         else
         {
-            registry.Set(FilePathKey_DevWriteStorage, path.LexicallyNormal().Native());
-            registry.Set(FilePathKey_ProjectUserPath, (path / "user").LexicallyNormal().Native());
-            registry.Set(FilePathKey_ProjectLogPath, (path / "user/log").LexicallyNormal().Native());
-        }
-#endif // AZ_TRAIT_OS_IS_HOST_OS_PLATFORM
+            registry.Set(FilePathKey_DevWriteStorage, projectPath.Native());
+            registry.Set(FilePathKey_ProjectUserPath, (projectPath / "user").Native());
+            registry.Set(FilePathKey_ProjectLogPath, (projectPath / "user" / "log").Native());
     }
+#endif // AZ_TRAIT_OS_IS_HOST_OS_PLATFORM
+}
 
     void MergeSettingsToRegistry_TargetBuildDependencyRegistry(SettingsRegistryInterface& registry, const AZStd::string_view platform,
         const SettingsRegistryInterface::Specializations& specializations, AZStd::vector<char>* scratchBuffer)
diff --git a/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h b/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h
index daa64c0343..56eec91813 100644
--- a/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h
+++ b/Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h
@@ -87,9 +87,9 @@ namespace AZ::SettingsRegistryMergeUtils
     AZ::IO::FixedMaxPath FindEngineRoot(SettingsRegistryInterface& settingsRegistry);
 
     //! The algorithm that is used to find the project root is as follows
-    //! 1. The first time this function is it performs a upward scan for a project.json file from
-    //! the executable directory and if found stores that path to an internal key.
-    //! In the same step it injects the path into the front of list of command line parameters
+    //! 1. The first time this function runs it performs an upward scan for a "project.json" file from
+    //! the executable directory and stores that path into an internal key.
+    //! In the same step it injects the path into the back of the command line parameters
     //! using the --regset="{BootstrapSettingsRootKey}/project_path=<path>" value
     //! 2. Next the "{BootstrapSettingsRootKey}/project_path" is checked to see if it has a project path set
     //!
diff --git a/Code/Framework/AzFramework/Tests/ArchiveCompressionTests.cpp b/Code/Framework/AzFramework/Tests/ArchiveCompressionTests.cpp
index 6cde5b5e84..aa1a27f9b0 100644
--- a/Code/Framework/AzFramework/Tests/ArchiveCompressionTests.cpp
+++ b/Code/Framework/AzFramework/Tests/ArchiveCompressionTests.cpp
@@ -41,7 +41,9 @@ namespace UnitTest
 
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_application->Start({});
diff --git a/Code/Framework/AzFramework/Tests/ArchiveTests.cpp b/Code/Framework/AzFramework/Tests/ArchiveTests.cpp
index 37babb49a8..ff0e3ab724 100644
--- a/Code/Framework/AzFramework/Tests/ArchiveTests.cpp
+++ b/Code/Framework/AzFramework/Tests/ArchiveTests.cpp
@@ -45,7 +45,9 @@ namespace UnitTest
 
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_application->Start({});
diff --git a/Code/Framework/AzFramework/Tests/AssetCatalog.cpp b/Code/Framework/AzFramework/Tests/AssetCatalog.cpp
index 9e5c72f74c..8a24d164cd 100644
--- a/Code/Framework/AzFramework/Tests/AssetCatalog.cpp
+++ b/Code/Framework/AzFramework/Tests/AssetCatalog.cpp
@@ -305,7 +305,9 @@ namespace UnitTest
             AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             AZ::ComponentApplication::StartupParameters startupParameters;
diff --git a/Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp b/Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp
index f0417d206e..36acf2b063 100644
--- a/Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp
+++ b/Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp
@@ -87,7 +87,7 @@ namespace AzGameFramework
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_ProjectRegistry(registry, AZ_TRAIT_OS_PLATFORM_CODENAME, specializations, &scratchBuffer);
 #endif
 
-        // Used the lowercase the platform name since the bootstrap.game.<config>.<platform>.setreg is being loaded
+        // Used the lowercase the platform name since the bootstrap.game.<config>.setreg is being loaded
         // from the asset cache root where all the files are in lowercased from regardless of the filesystem case-sensitivity
         static constexpr char filename[] = "bootstrap.game." AZ_BUILD_CONFIGURATION_TYPE  ".setreg";
 
diff --git a/Code/Framework/AzToolsFramework/Tests/AssetFileInfoListComparison.cpp b/Code/Framework/AzToolsFramework/Tests/AssetFileInfoListComparison.cpp
index ad80b5c39d..af0ae9addb 100644
--- a/Code/Framework/AzToolsFramework/Tests/AssetFileInfoListComparison.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/AssetFileInfoListComparison.cpp
@@ -57,9 +57,7 @@ namespace UnitTest
             ArgumentContainer argContainer{ {} };
 
             // Append Command Line override for the Project Cache Path
-            auto projectCachePathOverride = FixedValueString::format(R"(--project-cache-path="%s")", m_tempDir.GetDirectory());
-            auto projectPathOverride = FixedValueString{ R"(--project-path=AutomatedTesting)" };
-            argContainer.push_back(projectCachePathOverride.data());
+            auto projectPathOverride = FixedValueString::format(R"(--project-path="%s")", m_tempDir.GetDirectory());
             argContainer.push_back(projectPathOverride.data());
             m_application = new ToolsTestApplication("AssetFileInfoListComparisonTest", aznumeric_caster(argContainer.size()), argContainer.data());
             AzToolsFramework::AssetSeedManager assetSeedManager;
@@ -100,7 +98,7 @@ namespace UnitTest
             m_application->Start(AzFramework::Application::Descriptor());
 
             // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
-            // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash 
+            // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash
             // in the unit tests.
             AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
 
@@ -223,7 +221,7 @@ namespace UnitTest
 
             // AssetFileInfo should contain {2*, 4*, 5}
             AzToolsFramework::AssetFileInfoList assetFileInfoList;
-           
+
             ASSERT_TRUE(AZ::Utils::LoadObjectFromFileInPlace(TempFiles[FileIndex::ResultAssetFileInfoList], assetFileInfoList)) << "Unable to read the asset file info list.\n";
 
             EXPECT_EQ(assetFileInfoList.m_fileInfoList.size(), 3);
@@ -256,7 +254,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[2], m_assets[4], m_assets[5] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -298,7 +296,7 @@ namespace UnitTest
             {
                 firstAssetIdToAssetFileInfoMap[assetFileInfo.m_assetId] = AZStd::move(assetFileInfo);
             }
-            
+
             AzToolsFramework::AssetFileInfoList secondAssetFileInfoList;
             ASSERT_TRUE(AZ::Utils::LoadObjectFromFileInPlace(TempFiles[FileIndex::SecondAssetFileInfoList], secondAssetFileInfoList)) << "Unable to read the asset file info list.\n";
 
@@ -315,7 +313,7 @@ namespace UnitTest
                 auto foundSecond = secondAssetIdToAssetFileInfoMap.find(assetFileInfo.m_assetId);
                 if (foundSecond != secondAssetIdToAssetFileInfoMap.end())
                 {
-                    // Even if the asset Id is present in both the AssetFileInfo List, it should match the file hash from the second AssetFileInfo list 
+                    // Even if the asset Id is present in both the AssetFileInfo List, it should match the file hash from the second AssetFileInfo list
                     for (int idx = 0; idx < AzToolsFramework::AssetFileInfo::s_arraySize; idx++)
                     {
                         if (foundSecond->second.m_hash[idx] != assetFileInfo.m_hash[idx])
@@ -343,7 +341,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[0], m_assets[1], m_assets[2], m_assets[3], m_assets[4], m_assets[5] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -403,7 +401,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[1], m_assets[2], m_assets[3], m_assets[4] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -462,7 +460,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[5] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -493,7 +491,7 @@ namespace UnitTest
 
             EXPECT_EQ(assetFileInfoList.m_fileInfoList.size(), 5);
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[0], m_assets[1], m_assets[2], m_assets[3], m_assets[4] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -601,7 +599,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[2] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -625,12 +623,12 @@ namespace UnitTest
             AssetFileInfoListComparison::ComparisonData filePatternComparisonData(AssetFileInfoListComparison::ComparisonType::FilePattern,"$1", "Asset[0-3].txt", AssetFileInfoListComparison::FilePatternType::Regex);
             filePatternComparisonData.m_firstInput = TempFiles[FileIndex::FirstAssetFileInfoList];
             assetFileInfoListComparison.AddComparisonStep(filePatternComparisonData);
-            
+
             AzToolsFramework::AssetFileInfoListComparison::ComparisonData deltaComparisonData(AzToolsFramework::AssetFileInfoListComparison::ComparisonType::Delta, TempFiles[FileIndex::ResultAssetFileInfoList]);
             deltaComparisonData.m_firstInput = "$1";
             deltaComparisonData.m_secondInput = TempFiles[FileIndex::SecondAssetFileInfoList];
             assetFileInfoListComparison.AddComparisonStep(deltaComparisonData);
-            
+
             ASSERT_TRUE(assetFileInfoListComparison.CompareAndSaveResults().IsSuccess()) << "Multiple Comparison Operation( FilePattern + Delta ) failed.\n";
             // Output of the FilePattern Operation should be {0,1,2,3}
             // Output of the Delta Operation should be {2*,4*,5}
@@ -666,7 +664,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[2], m_assets[4], m_assets[5] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
@@ -738,7 +736,7 @@ namespace UnitTest
                 }
             }
 
-            // Verifying that correct assetId are present in the assetFileInfo list 
+            // Verifying that correct assetId are present in the assetFileInfo list
             AZStd::unordered_set<AZ::Data::AssetId> expectedAssetIds{ m_assets[4], m_assets[5] };
 
             for (const AzToolsFramework::AssetFileInfo& assetFileInfo : assetFileInfoList.m_fileInfoList)
diff --git a/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp b/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp
index 827737f561..f04a0642d1 100644
--- a/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp
@@ -63,10 +63,8 @@ namespace UnitTest
             ArgumentContainer argContainer{ {} };
 
             // Append Command Line override for the Project Cache Path
-            AZ::IO::Path cacheProjectRootFolder{ m_tempDir.GetDirectory() };
-            auto projectCachePathOverride = FixedValueString::format(R"(--project-cache-path="%s")", cacheProjectRootFolder.c_str());
-            auto projectPathOverride = FixedValueString{ R"(--project-path=AutomatedTesting)" };
-            argContainer.push_back(projectCachePathOverride.data());
+            auto cacheProjectRootFolder = AZ::IO::Path{ m_tempDir.GetDirectory() } / "Cache";
+            auto projectPathOverride = FixedValueString::format(R"(--project-path="%s")", m_tempDir.GetDirectory());
             argContainer.push_back(projectPathOverride.data());
             m_application = new ToolsTestApplication("AssetSeedManagerTest", aznumeric_caster(argContainer.size()), argContainer.data());
             m_assetSeedManager = new AzToolsFramework::AssetSeedManager();
diff --git a/Code/Framework/AzToolsFramework/Tests/ComponentAddRemove.cpp b/Code/Framework/AzToolsFramework/Tests/ComponentAddRemove.cpp
index e416efc5c6..9d6c8a4bff 100644
--- a/Code/Framework/AzToolsFramework/Tests/ComponentAddRemove.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/ComponentAddRemove.cpp
@@ -572,7 +572,9 @@ namespace UnitTest
             AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             AzFramework::Application::Descriptor descriptor;
diff --git a/Code/Framework/AzToolsFramework/Tests/GenericComponentWrapperTest.cpp b/Code/Framework/AzToolsFramework/Tests/GenericComponentWrapperTest.cpp
index 54132b974e..dbe3963069 100644
--- a/Code/Framework/AzToolsFramework/Tests/GenericComponentWrapperTest.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/GenericComponentWrapperTest.cpp
@@ -59,7 +59,9 @@ protected:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         m_app.Start(AZ::ComponentApplication::Descriptor());
@@ -184,7 +186,9 @@ public:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
         
         m_app.Start(AzFramework::Application::Descriptor());
diff --git a/Code/Framework/AzToolsFramework/Tests/PlatformAddressedAssetCatalogTests.cpp b/Code/Framework/AzToolsFramework/Tests/PlatformAddressedAssetCatalogTests.cpp
index 9c226cbb1b..e58e347b2a 100644
--- a/Code/Framework/AzToolsFramework/Tests/PlatformAddressedAssetCatalogTests.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/PlatformAddressedAssetCatalogTests.cpp
@@ -44,10 +44,8 @@ namespace UnitTest
             ArgumentContainer argContainer{ {} };
 
             // Append Command Line override for the Project Cache Path
-            AZ::IO::Path cacheProjectRootFolder{ m_tempDir.GetDirectory() };
-            auto projectCachePathOverride = FixedValueString::format(R"(--project-cache-path="%s")", cacheProjectRootFolder.c_str());
-            auto projectPathOverride = FixedValueString{ R"(--project-path=AutomatedTesting)" };
-            argContainer.push_back(projectCachePathOverride.data());
+            auto cacheProjectRootFolder = AZ::IO::Path{ m_tempDir.GetDirectory() } / "Cache";
+            auto projectPathOverride = FixedValueString::format(R"(--project-path="%s")", m_tempDir.GetDirectory());
             argContainer.push_back(projectPathOverride.data());
             m_application = new ToolsTestApplication("AddressedAssetCatalogManager", aznumeric_caster(argContainer.size()), argContainer.data());
 
@@ -195,10 +193,7 @@ namespace UnitTest
             ArgumentContainer argContainer{ {} };
 
             // Append Command Line override for the Project Cache Path
-            AZ::IO::Path cacheProjectRootFolder{ m_tempDir.GetDirectory() };
-            auto projectCachePathOverride = FixedValueString::format(R"(--project-cache-path="%s")", cacheProjectRootFolder.c_str());
-            auto projectPathOverride = FixedValueString{ R"(--project-path=AutomatedTesting)" };
-            argContainer.push_back(projectCachePathOverride.data());
+            auto projectPathOverride = FixedValueString::format(R"(--project-path="%s")", m_tempDir.GetDirectory());
             argContainer.push_back(projectPathOverride.data());
             m_application = new ToolsTestApplication("MessageTest", aznumeric_caster(argContainer.size()), argContainer.data());
 
diff --git a/Code/Framework/AzToolsFramework/Tests/Slices.cpp b/Code/Framework/AzToolsFramework/Tests/Slices.cpp
index 1e849de620..9b546357cd 100644
--- a/Code/Framework/AzToolsFramework/Tests/Slices.cpp
+++ b/Code/Framework/AzToolsFramework/Tests/Slices.cpp
@@ -1059,7 +1059,9 @@ namespace UnitTest
             AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_app.Start(AzFramework::Application::Descriptor());
diff --git a/Code/Tools/AssetBundler/tests/applicationManagerTests.cpp b/Code/Tools/AssetBundler/tests/applicationManagerTests.cpp
index 0d915dcc49..07eae67a81 100644
--- a/Code/Tools/AssetBundler/tests/applicationManagerTests.cpp
+++ b/Code/Tools/AssetBundler/tests/applicationManagerTests.cpp
@@ -66,7 +66,9 @@ namespace AssetBundler
             }
             auto projectPathKey = AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey)
                 + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
 
diff --git a/Code/Tools/AssetBundler/tests/tests_main.cpp b/Code/Tools/AssetBundler/tests/tests_main.cpp
index 21a6bf8a6f..86432d730e 100644
--- a/Code/Tools/AssetBundler/tests/tests_main.cpp
+++ b/Code/Tools/AssetBundler/tests/tests_main.cpp
@@ -106,7 +106,9 @@ namespace AssetBundler
             }
             auto projectPathKey = AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey)
                 + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             AZ::IO::FixedMaxPath engineRoot = AZ::Utils::GetEnginePath();
diff --git a/Code/Tools/AssetProcessor/native/InternalBuilders/SettingsRegistryBuilder.cpp b/Code/Tools/AssetProcessor/native/InternalBuilders/SettingsRegistryBuilder.cpp
index 7823a0582f..305578219f 100644
--- a/Code/Tools/AssetProcessor/native/InternalBuilders/SettingsRegistryBuilder.cpp
+++ b/Code/Tools/AssetProcessor/native/InternalBuilders/SettingsRegistryBuilder.cpp
@@ -431,8 +431,9 @@ namespace AssetProcessor
                     }
                     file.Close();
 
-                    AZ::u32 hashedSpecialization = static_cast<AZ::u32>(AZStd::hash<AZStd::string_view>{}(specializationString));
-                    AZ_Assert(hashedSpecialization != 0, "Product ID generation failed for specialization %.*s. This can result in a product ID collision with other builders for this asset.",
+                    const AZ::u32 hashedSpecialization = static_cast<AZ::u32>(AZStd::hash<AZStd::string_view>{}(specializationString));
+                    AZ_Assert(hashedSpecialization != 0, "Product ID generation failed for specialization %.*s."
+                        " This can result in a product ID collision with other builders for this asset.",
                         AZ_STRING_ARG(specializationString));
                     response.m_outputProducts.emplace_back(outputPath, m_assetType, hashedSpecialization);
                     response.m_outputProducts.back().m_dependenciesHandled = true;
diff --git a/Code/Tools/AssetProcessor/native/tests/AssetCatalog/AssetCatalogUnitTests.cpp b/Code/Tools/AssetProcessor/native/tests/AssetCatalog/AssetCatalogUnitTests.cpp
index 2a1c4e4755..5c449e2764 100644
--- a/Code/Tools/AssetProcessor/native/tests/AssetCatalog/AssetCatalogUnitTests.cpp
+++ b/Code/Tools/AssetProcessor/native/tests/AssetCatalog/AssetCatalogUnitTests.cpp
@@ -128,7 +128,9 @@ namespace AssetProcessor
             settingsRegistry->Set(cacheRootKey, m_data->m_temporarySourceDir.absoluteFilePath("Cache").toUtf8().constData());
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            settingsRegistry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            settingsRegistry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            settingsRegistry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*settingsRegistry);
             AssetUtilities::ComputeProjectCacheRoot(m_data->m_cacheRootDir);
             QString normalizedCacheRoot = AssetUtilities::NormalizeDirectoryPath(m_data->m_cacheRootDir.absolutePath());
diff --git a/Code/Tools/AssetProcessor/native/tests/AssetProcessorMessagesTests.cpp b/Code/Tools/AssetProcessor/native/tests/AssetProcessorMessagesTests.cpp
index 516f6beb3c..6a0da96151 100644
--- a/Code/Tools/AssetProcessor/native/tests/AssetProcessorMessagesTests.cpp
+++ b/Code/Tools/AssetProcessor/native/tests/AssetProcessorMessagesTests.cpp
@@ -107,12 +107,13 @@ namespace AssetProcessorMessagesTests
                 AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey
             };
             constexpr AZ::SettingsRegistryInterface::FixedValueString projectPathKey{ bootstrapKey + "/project_path" };
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             // Force the branch token into settings registry before starting the application manager.
             // This avoids writing the asset_processor.setreg file which can cause fileIO errors.
-            const AZ::IO::FixedMaxPathString enginePath = AZ::Utils::GetEnginePath();
             constexpr AZ::SettingsRegistryInterface::FixedValueString branchTokenKey{ bootstrapKey + "/assetProcessor_branch_token" };
             AZStd::string token;
             AZ::StringFunc::AssetPath::CalculateBranchToken(enginePath.c_str(), token);
diff --git a/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.cpp b/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.cpp
index 3249b7e396..2629f7b956 100644
--- a/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.cpp
+++ b/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.cpp
@@ -71,12 +71,13 @@ namespace AssetProcessor
             auto registry = AZ::SettingsRegistry::Get();
             auto bootstrapKey = AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey);
             auto projectPathKey = bootstrapKey + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             // Forcing the branch token into settings registry before starting the application manager.
             // This avoids writing the asset_processor.setreg file which can cause fileIO errors.
-            AZ::IO::FixedMaxPathString enginePath = AZ::Utils::GetEnginePath();
             auto branchTokenKey = bootstrapKey + "/assetProcessor_branch_token";
             AZStd::string token;
             AzFramework::StringFunc::AssetPath::CalculateBranchToken(enginePath.c_str(), token);
diff --git a/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.h b/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.h
index 258268c182..719b04610c 100644
--- a/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.h
+++ b/Code/Tools/AssetProcessor/native/tests/AssetProcessorTest.h
@@ -50,7 +50,9 @@ namespace AssetProcessor
                 + "/project_path";
             if(auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
             {
-                settingsRegistry->Set(projectPathKey, "AutomatedTesting");
+                AZ::IO::FixedMaxPath enginePath;
+                settingsRegistry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+                settingsRegistry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
                 AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*settingsRegistry);
             }
         }
diff --git a/Code/Tools/AssetProcessor/native/tests/assetmanager/AssetProcessorManagerTest.cpp b/Code/Tools/AssetProcessor/native/tests/assetmanager/AssetProcessorManagerTest.cpp
index da6e995c97..59ae25601d 100644
--- a/Code/Tools/AssetProcessor/native/tests/assetmanager/AssetProcessorManagerTest.cpp
+++ b/Code/Tools/AssetProcessor/native/tests/assetmanager/AssetProcessorManagerTest.cpp
@@ -192,7 +192,9 @@ void AssetProcessorManagerTest::SetUp()
     registry->Set(cacheRootKey, tempPath.absoluteFilePath("Cache").toUtf8().constData());
     auto projectPathKey =
         AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-    registry->Set(projectPathKey, "AutomatedTesting");
+    AZ::IO::FixedMaxPath enginePath;
+    registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+    registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
     AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
     m_data->m_databaseLocationListener.BusConnect();
diff --git a/Code/Tools/DeltaCataloger/Tests/tests_main.cpp b/Code/Tools/DeltaCataloger/Tests/tests_main.cpp
index 1a3b86d34b..d5a344b686 100644
--- a/Code/Tools/DeltaCataloger/Tests/tests_main.cpp
+++ b/Code/Tools/DeltaCataloger/Tests/tests_main.cpp
@@ -45,7 +45,9 @@ protected:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         AZ::ComponentApplication::Descriptor desc;
diff --git a/Gems/AssetValidation/Code/Tests/AssetValidationTestShared.h b/Gems/AssetValidation/Code/Tests/AssetValidationTestShared.h
index 456afd0006..c4872ab425 100644
--- a/Gems/AssetValidation/Code/Tests/AssetValidationTestShared.h
+++ b/Gems/AssetValidation/Code/Tests/AssetValidationTestShared.h
@@ -150,7 +150,7 @@ struct AssetValidationTest
 
             auto projectPathKey = AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey)
                 + "/project_path";
-            m_registry.Set(projectPathKey, "AutomatedTesting");
+            m_registry.Set(projectPathKey, (AZ::IO::FixedMaxPath(GetEngineRoot()) / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(m_registry);
 
             // Set the engine root to the temporary directory and re-update the runtime file paths
diff --git a/Gems/EMotionFX/Code/Tests/SystemComponentFixture.h b/Gems/EMotionFX/Code/Tests/SystemComponentFixture.h
index 034fd2045b..62ebffa7e9 100644
--- a/Gems/EMotionFX/Code/Tests/SystemComponentFixture.h
+++ b/Gems/EMotionFX/Code/Tests/SystemComponentFixture.h
@@ -61,7 +61,9 @@ namespace EMotionFX
             constexpr auto projectPathKey = FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
             if(auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
             {
-                settingsRegistry->Set(projectPathKey, "AutomatedTesting");
+                AZ::IO::FixedMaxPath enginePath;
+                settingsRegistry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+                settingsRegistry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
                 AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*settingsRegistry);
             }
         }
diff --git a/Gems/EditorPythonBindings/Code/Tests/EditorPythonBindingsTest.cpp b/Gems/EditorPythonBindings/Code/Tests/EditorPythonBindingsTest.cpp
index d630605cbc..9dbbb34e6c 100644
--- a/Gems/EditorPythonBindings/Code/Tests/EditorPythonBindingsTest.cpp
+++ b/Gems/EditorPythonBindings/Code/Tests/EditorPythonBindingsTest.cpp
@@ -323,7 +323,9 @@ sys.version
             auto registry = AZ::SettingsRegistry::Get();
             auto projectPathKey = AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey)
                 + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_app.RegisterComponentDescriptor(EditorPythonBindings::PythonSystemComponent::CreateDescriptor());
diff --git a/Gems/LmbrCentral/Code/Tests/Builders/LevelBuilderTest.cpp b/Gems/LmbrCentral/Code/Tests/Builders/LevelBuilderTest.cpp
index e50fbbe56c..697c5c3b06 100644
--- a/Gems/LmbrCentral/Code/Tests/Builders/LevelBuilderTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/Builders/LevelBuilderTest.cpp
@@ -99,7 +99,9 @@ namespace UnitTest
             AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_app.Start(m_descriptor);
diff --git a/Gems/LmbrCentral/Code/Tests/Builders/LuaBuilderTests.cpp b/Gems/LmbrCentral/Code/Tests/Builders/LuaBuilderTests.cpp
index a9b36d4624..c62ed92c83 100644
--- a/Gems/LmbrCentral/Code/Tests/Builders/LuaBuilderTests.cpp
+++ b/Gems/LmbrCentral/Code/Tests/Builders/LuaBuilderTests.cpp
@@ -31,7 +31,9 @@ namespace UnitTest
             AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
             auto projectPathKey =
                 AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-            registry->Set(projectPathKey, "AutomatedTesting");
+            AZ::IO::FixedMaxPath enginePath;
+            registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+            registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
             m_app.Start(m_descriptor);
diff --git a/Gems/LmbrCentral/Code/Tests/Builders/SeedBuilderTests.cpp b/Gems/LmbrCentral/Code/Tests/Builders/SeedBuilderTests.cpp
index f679a3502d..574fd4edfb 100644
--- a/Gems/LmbrCentral/Code/Tests/Builders/SeedBuilderTests.cpp
+++ b/Gems/LmbrCentral/Code/Tests/Builders/SeedBuilderTests.cpp
@@ -22,7 +22,9 @@ class SeedBuilderTests
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         m_app.Start(AZ::ComponentApplication::Descriptor());
diff --git a/Gems/LyShine/Code/Tests/LyShineEditorTest.cpp b/Gems/LyShine/Code/Tests/LyShineEditorTest.cpp
index 60074ac0a0..59be8a85e1 100644
--- a/Gems/LyShine/Code/Tests/LyShineEditorTest.cpp
+++ b/Gems/LyShine/Code/Tests/LyShineEditorTest.cpp
@@ -85,7 +85,9 @@ protected:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         m_app.Start(m_descriptor);
diff --git a/Gems/Prefab/PrefabBuilder/PrefabBuilderTests.cpp b/Gems/Prefab/PrefabBuilder/PrefabBuilderTests.cpp
index ab6770c3fe..d33b453c01 100644
--- a/Gems/Prefab/PrefabBuilder/PrefabBuilderTests.cpp
+++ b/Gems/Prefab/PrefabBuilder/PrefabBuilderTests.cpp
@@ -174,7 +174,9 @@ namespace UnitTest
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         AZ::ComponentApplication::Descriptor desc;
diff --git a/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderPhasesTests.cpp b/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderPhasesTests.cpp
index 2709cd40b7..15d50bcfa3 100644
--- a/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderPhasesTests.cpp
+++ b/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderPhasesTests.cpp
@@ -139,7 +139,9 @@ public:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         m_app.Start(AZ::ComponentApplication::Descriptor());
diff --git a/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderTests.cpp b/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderTests.cpp
index 3a7b20553e..a1ca5be766 100644
--- a/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderTests.cpp
+++ b/Gems/SceneProcessing/Code/Tests/SceneBuilder/SceneBuilderTests.cpp
@@ -35,7 +35,9 @@ protected:
         AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
         auto projectPathKey =
             AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
-        registry->Set(projectPathKey, "AutomatedTesting");
+        AZ::IO::FixedMaxPath enginePath;
+        registry->Get(enginePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        registry->Set(projectPathKey, (enginePath / "AutomatedTesting").Native());
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
 
         m_app.Start(AZ::ComponentApplication::Descriptor());
diff --git a/cmake/Projects.cmake b/cmake/Projects.cmake
index 34ef3efd9b..2c42533e35 100644
--- a/cmake/Projects.cmake
+++ b/cmake/Projects.cmake
@@ -132,24 +132,7 @@ function(add_project_json_external_subdirectories project_path)
     endif()
 endfunction()
 
-# Add the projects here so the above function is found
-foreach(project ${LY_PROJECTS})
-    file(REAL_PATH ${project} full_directory_path BASE_DIRECTORY ${CMAKE_SOURCE_DIR})
-    string(SHA256 full_directory_hash ${full_directory_path})
-
-    # Truncate the full_directory_hash down to 8 characters to avoid hitting the Windows 260 character path limit
-    # when the external subdirectory contains relative paths of significant length
-    string(SUBSTRING ${full_directory_hash} 0 8 full_directory_hash)
-
-    get_filename_component(project_folder_name ${project} NAME)
-    list(APPEND LY_PROJECTS_FOLDER_NAME ${project_folder_name})
-    add_subdirectory(${project} "${project_folder_name}-${full_directory_hash}")
-    ly_generate_project_build_path_setreg(${full_directory_path})
-    add_project_json_external_subdirectories(${full_directory_path})
-
-    # Get project name
-    o3de_read_json_key(project_name ${full_directory_path}/project.json "project_name")
-
+function(install_project_asset_artifacts project_real_path)
     # The cmake tar command has a bit of a flaw
     # Any paths within the archive files it creates are relative to the current working directory.
     # That means with the setup of:
@@ -172,13 +155,12 @@ if("${CMAKE_INSTALL_CONFIG_NAME}" MATCHES "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$")
     if(NOT DEFINED LY_ASSET_DEPLOY_ASSET_TYPE)
         set(LY_ASSET_DEPLOY_ASSET_TYPE @LY_ASSET_DEPLOY_ASSET_TYPE@)
     endif()
-    message(STATUS "Generating ${install_pak_output_folder}/engine.pak from @full_directory_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
+    message(STATUS "Generating ${install_pak_output_folder}/engine.pak from @project_real_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
     file(MAKE_DIRECTORY "${install_pak_output_folder}")
-    cmake_path(SET cache_product_path "@full_directory_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
+    cmake_path(SET cache_product_path "@project_real_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
     # Copy the generated cmake_dependencies.*.setreg files for loading gems in non-monolithic to the cache
     file(GLOB gem_source_paths_setreg "${runtime_output_directory_RELEASE}/Registry/*.setreg")
-    # The MergeSettingsToRegistry_TargetBuildDependencyRegistry function looks for lowercase "registry"
-    # So make sure the to copy it to a lowercase path, so that it works on non-case sensitive filesystems
+    # The MergeSettingsToRegistry_TargetBuildDependencyRegistry function looks for lowercase "registry" directory
     file(MAKE_DIRECTORY "${cache_product_path}/registry")
     file(COPY ${gem_source_paths_setreg} DESTINATION "${cache_product_path}/registry")
 
@@ -194,11 +176,40 @@ if("${CMAKE_INSTALL_CONFIG_NAME}" MATCHES "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$")
             message(STATUS "${install_output_folder}/engine.pak generated")
         endif()
     endif()
+
+    # Remove copied .setreg files from the Cache directory
+    unset(artifacts_to_remove)
+    foreach(gem_source_path_setreg IN LISTS gem_source_paths_setreg)
+        cmake_path(GET gem_source_path_setreg FILENAME setreg_filename)
+        list(APPEND artifacts_to_remove "${cache_product_path}/registry/${setreg_filename}")
+    endforeach()
+    file(REMOVE ${artifacts_to_remove})
 endif()
 ]=])
 
     string(CONFIGURE "${install_engine_pak_template}" install_engine_pak_code @ONLY)
     ly_install_run_code("${install_engine_pak_code}")
+endfunction()
+
+# Add the projects here so the above function is found
+foreach(project ${LY_PROJECTS})
+    file(REAL_PATH ${project} full_directory_path BASE_DIRECTORY ${CMAKE_SOURCE_DIR})
+    string(SHA256 full_directory_hash ${full_directory_path})
+
+    # Truncate the full_directory_hash down to 8 characters to avoid hitting the Windows 260 character path limit
+    # when the external subdirectory contains relative paths of significant length
+    string(SUBSTRING ${full_directory_hash} 0 8 full_directory_hash)
+
+    get_filename_component(project_folder_name ${project} NAME)
+    list(APPEND LY_PROJECTS_FOLDER_NAME ${project_folder_name})
+    add_subdirectory(${project} "${project_folder_name}-${full_directory_hash}")
+    ly_generate_project_build_path_setreg(${full_directory_path})
+    add_project_json_external_subdirectories(${full_directory_path})
+
+    # Get project name
+    o3de_read_json_key(project_name ${full_directory_path}/project.json "project_name")
+
+   install_project_asset_artifacts(${full_directory_path})
 
 endforeach()
 
diff --git a/scripts/build/Platform/Linux/asset_linux.sh b/scripts/build/Platform/Linux/asset_linux.sh
index df910db646..10f7ee6b6f 100755
--- a/scripts/build/Platform/Linux/asset_linux.sh
+++ b/scripts/build/Platform/Linux/asset_linux.sh
@@ -9,6 +9,8 @@
 
 set -o errexit # exit on the first failure encountered
 
+SOURCE_DIRECTORY=${PWD}
+
 if [[ ! -d $OUTPUT_DIRECTORY ]]; then
     echo [ci_build] Error: $OUTPUT_DIRECTORY was not found
     exit 1
@@ -22,8 +24,8 @@ fi
 
 for project in $(echo $CMAKE_LY_PROJECTS | sed "s/;/ /g")
 do
-    echo [ci_build] ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$project --platforms=$ASSET_PROCESSOR_PLATFORMS
-    ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$project --platforms=$ASSET_PROCESSOR_PLATFORMS
+    echo [ci_build] ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$SOURCE_DIRECTORY/$project --platforms=$ASSET_PROCESSOR_PLATFORMS
+    ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$SOURCE_DIRECTORY/$project --platforms=$ASSET_PROCESSOR_PLATFORMS
 done
 
 popd
diff --git a/scripts/build/Platform/Mac/asset_mac.sh b/scripts/build/Platform/Mac/asset_mac.sh
index f70d898e0c..96eaeab5aa 100755
--- a/scripts/build/Platform/Mac/asset_mac.sh
+++ b/scripts/build/Platform/Mac/asset_mac.sh
@@ -9,6 +9,8 @@
 
 set -o errexit # exit on the first failure encountered
 
+SOURCE_DIRECTORY=${PWD}
+
 if [[ ! -d $OUTPUT_DIRECTORY ]]; then
     echo [ci_build] Error: $OUTPUT_DIRECTORY was not found
     exit 1
@@ -22,8 +24,8 @@ fi
 
 for project in $(echo $CMAKE_LY_PROJECTS | sed "s/;/ /g")
 do
-    echo  [ci_build] ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$project --platforms=$ASSET_PROCESSOR_PLATFORMS
-    ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$project --platforms=$ASSET_PROCESSOR_PLATFORMS
+    echo  [ci_build] ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$SOURCE_DIRECTORY/$project --platforms=$ASSET_PROCESSOR_PLATFORMS
+    ${ASSET_PROCESSOR_BINARY} $ASSET_PROCESSOR_OPTIONS --project-path=$SOURCE_DIRECTORY/$project --platforms=$ASSET_PROCESSOR_PLATFORMS
 done
 
 popd
diff --git a/scripts/build/Platform/Windows/asset_windows.cmd b/scripts/build/Platform/Windows/asset_windows.cmd
index 8db0e43e31..cc266ba42a 100644
--- a/scripts/build/Platform/Windows/asset_windows.cmd
+++ b/scripts/build/Platform/Windows/asset_windows.cmd
@@ -9,6 +9,8 @@ REM
 
 SETLOCAL EnableDelayedExpansion
 
+SET SOURCE_DIRECTORY=%CD%
+
 IF NOT EXIST %OUTPUT_DIRECTORY% (
     ECHO [ci_build] Error: %OUTPUT_DIRECTORY% was not found
     GOTO :error
@@ -21,8 +23,8 @@ IF NOT EXIST %ASSET_PROCESSOR_BINARY% (
 )
 
 FOR %%P in (%CMAKE_LY_PROJECTS%) do (
-    ECHO [ci_build] %ASSET_PROCESSOR_BINARY% %ASSET_PROCESSOR_OPTIONS% --project-path=%%P --platforms=%ASSET_PROCESSOR_PLATFORMS%
-    %ASSET_PROCESSOR_BINARY% %ASSET_PROCESSOR_OPTIONS% --project-path=%%P --platforms=%ASSET_PROCESSOR_PLATFORMS%
+    ECHO [ci_build] %ASSET_PROCESSOR_BINARY% %ASSET_PROCESSOR_OPTIONS% --project-path=%SOURCE_DIRECTORY%/%%P --platforms=%ASSET_PROCESSOR_PLATFORMS%
+    %ASSET_PROCESSOR_BINARY% %ASSET_PROCESSOR_OPTIONS% --project-path=%SOURCE_DIRECTORY%/%%P --platforms=%ASSET_PROCESSOR_PLATFORMS%
     IF NOT !ERRORLEVEL!==0 GOTO :popd_error
 )