diff --git a/ydb/core/base/subdomain.h b/ydb/core/base/subdomain.h
index 3849bd8ca816..e7c1bcc3e304 100644
--- a/ydb/core/base/subdomain.h
+++ b/ydb/core/base/subdomain.h
@@ -31,7 +31,7 @@ struct TSubDomainKey : public std::pair<ui64, ui64> {
 
 static const TSubDomainKey InvalidSubDomainKey = TSubDomainKey();
 
-using TMaybeServerlessComputeResourcesMode = TMaybe<NKikimrSubDomains::EServerlessComputeResourcesMode, NMaybe::TPolicyUndefinedFail>;
+using TMaybeServerlessComputeResourcesMode = TMaybeFail<NKikimrSubDomains::EServerlessComputeResourcesMode>;
 }
 
 template <>
diff --git a/ydb/core/discovery/discovery.cpp b/ydb/core/discovery/discovery.cpp
index ae0d86ac15e0..4bffc082bce6 100644
--- a/ydb/core/discovery/discovery.cpp
+++ b/ydb/core/discovery/discovery.cpp
@@ -499,10 +499,14 @@ class TDiscoverer: public TActorBootstrapped<TDiscoverer> {
             return false;
         }
 
-        switch (domainInfo->ServerlessComputeResourcesMode) {
-            case NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED:
+        if (domainInfo->ServerlessComputeResourcesMode.Empty()) {
+            return true;
+        }
+
+        switch (*domainInfo->ServerlessComputeResourcesMode) {
+            case NKikimrSubDomains::EServerlessComputeResourcesModeExclusive:
                 return false;
-            case NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED:
+            case NKikimrSubDomains::EServerlessComputeResourcesModeShared:
                 return true;
             default:
                 return true;
diff --git a/ydb/core/mind/hive/domain_info.cpp b/ydb/core/mind/hive/domain_info.cpp
index 27f0e6747cc7..5c47ee219cb7 100644
--- a/ydb/core/mind/hive/domain_info.cpp
+++ b/ydb/core/mind/hive/domain_info.cpp
@@ -4,14 +4,14 @@ namespace NKikimr {
 namespace NHive {
 
 ENodeSelectionPolicy TDomainInfo::GetNodeSelectionPolicy() const {
-    if (!ServerlessComputeResourcesMode) {
+    if (ServerlessComputeResourcesMode.Empty()) {
         return ENodeSelectionPolicy::Default;
     }
 
     switch (*ServerlessComputeResourcesMode) {
-        case NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED:
+        case NKikimrSubDomains::EServerlessComputeResourcesModeExclusive:
             return ENodeSelectionPolicy::PreferObjectDomain;
-        case NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED:
+        case NKikimrSubDomains::EServerlessComputeResourcesModeShared:
             return ENodeSelectionPolicy::Default;
         default:
             return ENodeSelectionPolicy::Default;
diff --git a/ydb/core/mind/hive/hive_domains.cpp b/ydb/core/mind/hive/hive_domains.cpp
index 0f5536f18a4d..39933537cf3b 100644
--- a/ydb/core/mind/hive/hive_domains.cpp
+++ b/ydb/core/mind/hive/hive_domains.cpp
@@ -66,7 +66,7 @@ void THive::Handle(TEvHive::TEvUpdateDomain::TPtr& ev) {
     BLOG_D("Handle TEvHive::TEvUpdateDomain(" << ev->Get()->Record.ShortDebugString() << ")");
     const TSubDomainKey subdomainKey(ev->Get()->Record.GetDomainKey());
     TDomainInfo& domainInfo = Domains[subdomainKey];
-    if (ev->Get()->Record.GetServerlessComputeResourcesMode() != NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED) {
+    if (ev->Get()->Record.HasServerlessComputeResourcesMode()) {
         domainInfo.ServerlessComputeResourcesMode = ev->Get()->Record.GetServerlessComputeResourcesMode();
     } else {
         domainInfo.ServerlessComputeResourcesMode.Clear();
@@ -75,18 +75,11 @@ void THive::Handle(TEvHive::TEvUpdateDomain::TPtr& ev) {
 }
 
 TString THive::GetDomainName(TSubDomainKey domain) {
-    auto itDomain = Domains.find(domain);
-    if (itDomain != Domains.end()) {
-        if (!itDomain->second.Path.empty()) {
-            return itDomain->second.Path;
-        }
-    } else {
-        SeenDomain(domain);
-    }
     if (domain == TSubDomainKey()) {
         return "<empty-subdomain-key>";
     }
-    return TStringBuilder() << domain;
+    SeenDomain(domain);
+    return Domains.at(domain).Path;
 }
 
 } // NHive
diff --git a/ydb/core/mind/hive/hive_ut.cpp b/ydb/core/mind/hive/hive_ut.cpp
index b28ee8db4b96..b45e174fd9c3 100644
--- a/ydb/core/mind/hive/hive_ut.cpp
+++ b/ydb/core/mind/hive/hive_ut.cpp
@@ -6071,7 +6071,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
             ev->Record.SetTxId(++txId);
             ev->Record.MutableDomainKey()->SetSchemeShard(subdomainKey.GetSchemeShard());
             ev->Record.MutableDomainKey()->SetPathId(subdomainKey.GetPathId());
-            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED);
+            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::EServerlessComputeResourcesModeExclusive);
             runtime.SendToPipe(hiveTablet, sender, ev.Release());
             TAutoPtr<IEventHandle> handle;
             TEvHive::TEvUpdateDomainReply* response = runtime.GrabEdgeEventRethrow<TEvHive::TEvUpdateDomainReply>(handle);
@@ -6096,7 +6096,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
             ev->Record.SetTxId(++txId);
             ev->Record.MutableDomainKey()->SetSchemeShard(subdomainKey.GetSchemeShard());
             ev->Record.MutableDomainKey()->SetPathId(subdomainKey.GetPathId());
-            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED);
+            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::EServerlessComputeResourcesModeShared);
             runtime.SendToPipe(hiveTablet, sender, ev.Release());
             TAutoPtr<IEventHandle> handle;
             TEvHive::TEvUpdateDomainReply* response = runtime.GrabEdgeEventRethrow<TEvHive::TEvUpdateDomainReply>(handle);
@@ -6177,7 +6177,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
             ev->Record.SetTxId(++txId);
             ev->Record.MutableDomainKey()->SetSchemeShard(subdomainKey.GetSchemeShard());
             ev->Record.MutableDomainKey()->SetPathId(subdomainKey.GetPathId());
-            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED);
+            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::EServerlessComputeResourcesModeExclusive);
             runtime.SendToPipe(hiveTablet, sender, ev.Release());
             TAutoPtr<IEventHandle> handle;
             TEvHive::TEvUpdateDomainReply* response = runtime.GrabEdgeEventRethrow<TEvHive::TEvUpdateDomainReply>(handle);
@@ -6203,7 +6203,6 @@ Y_UNIT_TEST_SUITE(THiveTest) {
             ev->Record.SetTxId(++txId);
             ev->Record.MutableDomainKey()->SetSchemeShard(subdomainKey.GetSchemeShard());
             ev->Record.MutableDomainKey()->SetPathId(subdomainKey.GetPathId());
-            ev->Record.SetServerlessComputeResourcesMode(NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED);
             runtime.SendToPipe(hiveTablet, sender, ev.Release());
             TAutoPtr<IEventHandle> handle;
             TEvHive::TEvUpdateDomainReply* response = runtime.GrabEdgeEventRethrow<TEvHive::TEvUpdateDomainReply>(handle);
diff --git a/ydb/core/protos/subdomains.proto b/ydb/core/protos/subdomains.proto
index e740544f8565..79585c33ce6c 100644
--- a/ydb/core/protos/subdomains.proto
+++ b/ydb/core/protos/subdomains.proto
@@ -88,6 +88,7 @@ message TDomainDescription {
     optional uint64 ShardsLimit = 9;
 
     optional TDomainKey ResourcesDomainKey = 10;
+    optional fixed64 SharedHive = 22;
     optional EServerlessComputeResourcesMode ServerlessComputeResourcesMode = 23;
 
     optional TDiskSpaceUsage DiskSpaceUsage = 11; // TODO: temp for SLYDB-95
@@ -103,7 +104,6 @@ message TDomainDescription {
     optional NLoginProto.TSecurityState SecurityState = 20;
 
     optional TAuditSettings AuditSettings = 21;
-    optional fixed64 SharedHive = 22;
 }
 
 message TSchemeQuotas {
@@ -116,7 +116,7 @@ message TSchemeQuota {
 }
 
 enum EServerlessComputeResourcesMode {
-    SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED = 0;
-    SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED = 1;     // using nodes that serve resources domain
-    SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED = 2;  // using nodes that serve self domain
+    EServerlessComputeResourcesModeUnspecified = 0;
+    EServerlessComputeResourcesModeShared = 1;     // Using nodes that serve shared resources domain
+    EServerlessComputeResourcesModeExclusive = 2;  // Using nodes that serve self domain
 }
diff --git a/ydb/core/testlib/tablet_helpers.cpp b/ydb/core/testlib/tablet_helpers.cpp
index 5d62205c0c6f..61cd38d945a4 100644
--- a/ydb/core/testlib/tablet_helpers.cpp
+++ b/ydb/core/testlib/tablet_helpers.cpp
@@ -1447,8 +1447,12 @@ namespace NKikimr {
             
             const TSubDomainKey subdomainKey(ev->Get()->Record.GetDomainKey());
             NHive::TDomainInfo& domainInfo = State->Domains[subdomainKey];
-            domainInfo.ServerlessComputeResourcesMode = ev->Get()->Record.GetServerlessComputeResourcesMode();
-
+            if (ev->Get()->Record.HasServerlessComputeResourcesMode()) {
+                domainInfo.ServerlessComputeResourcesMode = ev->Get()->Record.GetServerlessComputeResourcesMode();
+            } else {
+                domainInfo.ServerlessComputeResourcesMode.Clear();
+            }
+            
             auto response = std::make_unique<TEvHive::TEvUpdateDomainReply>();
             response->Record.SetTxId(ev->Get()->Record.GetTxId());
             response->Record.SetOrigin(TabletID());
diff --git a/ydb/core/tx/scheme_cache/scheme_cache.h b/ydb/core/tx/scheme_cache/scheme_cache.h
index 18b456aaad41..5ccea3f421a1 100644
--- a/ydb/core/tx/scheme_cache/scheme_cache.h
+++ b/ydb/core/tx/scheme_cache/scheme_cache.h
@@ -3,6 +3,7 @@
 #include <ydb/core/base/events.h>
 #include <ydb/core/scheme/scheme_pathid.h>
 #include <ydb/core/base/tx_processing.h>
+#include <ydb/core/base/subdomain.h>
 #include <ydb/core/protos/flat_scheme_op.pb.h>
 #include <ydb/core/protos/flat_tx_scheme.pb.h>
 #include <ydb/core/protos/subdomains.pb.h>
@@ -55,13 +56,16 @@ struct TDomainInfo : public TAtomicRefCount<TDomainInfo> {
         : DomainKey(GetDomainKey(descr.GetDomainKey()))
         , Params(descr.GetProcessingParams())
         , Coordinators(descr.GetProcessingParams())
-        , ServerlessComputeResourcesMode(descr.GetServerlessComputeResourcesMode())
     {
         if (descr.HasResourcesDomainKey()) {
             ResourcesDomainKey = GetDomainKey(descr.GetResourcesDomainKey());
         } else {
             ResourcesDomainKey = DomainKey;
         }
+
+        if (descr.HasServerlessComputeResourcesMode()) {
+            ServerlessComputeResourcesMode = descr.GetServerlessComputeResourcesMode();
+        }
     }
 
     inline ui64 GetVersion() const {
@@ -84,8 +88,7 @@ struct TDomainInfo : public TAtomicRefCount<TDomainInfo> {
     TPathId ResourcesDomainKey;
     NKikimrSubDomains::TProcessingParams Params;
     TCoordinators Coordinators;
-    NKikimrSubDomains::EServerlessComputeResourcesMode ServerlessComputeResourcesMode =
-        NKikimrSubDomains::SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED;
+    TMaybeServerlessComputeResourcesMode ServerlessComputeResourcesMode;
 
     TString ToString() const;
 
diff --git a/ydb/core/tx/schemeshard/schemeshard__init.cpp b/ydb/core/tx/schemeshard/schemeshard__init.cpp
index f0ca056958b6..5592f5587819 100644
--- a/ydb/core/tx/schemeshard/schemeshard__init.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__init.cpp
@@ -1535,6 +1535,10 @@ struct TSchemeShard::TTxInit : public TTransactionBase<TSchemeShard> {
                         domainInfo->SetServerlessComputeResourcesMode(
                             rowset.GetValue<Schema::SubDomains::ServerlessComputeResourcesMode>()
                         );
+                    } else if (Self->IsServerlessDomain(domainInfo) || Self->IsServerlessDomainGlobal(pathId, domainInfo)) {
+                        domainInfo->SetServerlessComputeResourcesMode(
+                            NKikimrSubDomains::EServerlessComputeResourcesModeShared
+                        );
                     }
                 }
 
@@ -1603,6 +1607,10 @@ struct TSchemeShard::TTxInit : public TTransactionBase<TSchemeShard> {
                         alter->SetServerlessComputeResourcesMode(
                             rowset.GetValue<Schema::SubDomainsAlterData::ServerlessComputeResourcesMode>()
                         );
+                    } else if (Self->IsServerlessDomain(alter) || Self->IsServerlessDomainGlobal(pathId, alter)) {
+                        alter->SetServerlessComputeResourcesMode(
+                            NKikimrSubDomains::EServerlessComputeResourcesModeShared
+                        );
                     }
 
                     subdomainInfo->SetAlter(alter);
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_alter_extsubdomain.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_alter_extsubdomain.cpp
index c8d287c3a492..eabfe8042b64 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_alter_extsubdomain.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_alter_extsubdomain.cpp
@@ -273,10 +273,10 @@ VerifyParams(TParamsDelta* delta, const TPathId pathId, const TSubDomainInfo::TP
         }
 
         switch (input.GetServerlessComputeResourcesMode()) {
-            case EServerlessComputeResourcesMode::SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED:
-                return paramError("can not set ServerlessComputeResourcesMode to SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED");
-            case EServerlessComputeResourcesMode::SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED:
-            case EServerlessComputeResourcesMode::SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED:
+            case EServerlessComputeResourcesMode::EServerlessComputeResourcesModeUnspecified:
+                return paramError("can not set ServerlessComputeResourcesMode to EServerlessComputeResourcesModeUnspecified");
+            case EServerlessComputeResourcesMode::EServerlessComputeResourcesModeExclusive:
+            case EServerlessComputeResourcesMode::EServerlessComputeResourcesModeShared:
                 break; // ok
             default:
                 return paramError("unknown ServerlessComputeResourcesMode");
@@ -769,7 +769,7 @@ class TSyncHive: public TSubOperationState {
             event->Record.MutableDomainKey()->SetSchemeShard(pathId.OwnerId);
             event->Record.MutableDomainKey()->SetPathId(pathId.LocalPathId);
             const auto& serverlessComputeResourcesMode = subDomain->GetServerlessComputeResourcesMode();
-            if (serverlessComputeResourcesMode) {
+            if (serverlessComputeResourcesMode.Defined()) {
                 event->Record.SetServerlessComputeResourcesMode(*serverlessComputeResourcesMode);
             }
 
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_create_extsubdomain.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_create_extsubdomain.cpp
index 3bb61ca5b364..34270aad280d 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_create_extsubdomain.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_create_extsubdomain.cpp
@@ -217,6 +217,7 @@ class TCreateExtSubDomain: public TSubOperation {
             }
 
             alter->SetSharedHive(sharedHive);
+            alter->SetServerlessComputeResourcesMode(NKikimrSubDomains::EServerlessComputeResourcesModeShared);
         }
 
         if (settings.HasDeclaredSchemeQuotas()) {
diff --git a/ydb/core/tx/schemeshard/schemeshard_impl.h b/ydb/core/tx/schemeshard/schemeshard_impl.h
index 5d058ee89c3e..e7f9c4e3150c 100644
--- a/ydb/core/tx/schemeshard/schemeshard_impl.h
+++ b/ydb/core/tx/schemeshard/schemeshard_impl.h
@@ -333,6 +333,11 @@ class TSchemeShard
         return IsServerlessDomain(domain.DomainInfo());
     }
 
+    bool IsServerlessDomainGlobal(TPathId domainPathId, TSubDomainInfo::TConstPtr domainInfo) const {
+        const auto& resourcesDomainId = domainInfo->GetResourcesDomainId();
+        return IsDomainSchemeShard && resourcesDomainId && resourcesDomainId != domainPathId;
+    }
+
     TPathId MakeLocalId(const TLocalPathId& localPathId) const {
         return TPathId(TabletID(), localPathId);
     }
diff --git a/ydb/core/tx/schemeshard/ut_serverless/ut_serverless.cpp b/ydb/core/tx/schemeshard/ut_serverless/ut_serverless.cpp
index 11b4e2f79222..1dd78d91a150 100644
--- a/ydb/core/tx/schemeshard/ut_serverless/ut_serverless.cpp
+++ b/ydb/core/tx/schemeshard/ut_serverless/ut_serverless.cpp
@@ -285,10 +285,24 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
         env.TestWaitNotification(runtime, txId);
 
         ui64 sharedHive = 0;
+        ui64 sharedDbSchemeShard = 0;
         TestDescribeResult(DescribePath(runtime, "/MyRoot/SharedDB"),
                            {NLs::PathExist,
                             NLs::IsExternalSubDomain("SharedDB"),
-                            NLs::ExtractDomainHive(&sharedHive)});
+                            NLs::ExtractDomainHive(&sharedHive),
+                            NLs::ExtractTenantSchemeshard(&sharedDbSchemeShard),
+                            NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeUnspecified)});
+
+        UNIT_ASSERT(sharedHive != 0
+                    && sharedHive != (ui64)-1
+                    && sharedHive != TTestTxConfig::Hive);
+        UNIT_ASSERT(sharedDbSchemeShard != 0
+                    && sharedDbSchemeShard != (ui64)-1
+                    && sharedDbSchemeShard != TTestTxConfig::SchemeShard);
+                    
+        TestDescribeResult(DescribePath(runtime, sharedDbSchemeShard, "/MyRoot/SharedDB"),
+                           {NLs::PathExist,
+                            NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeUnspecified)});
 
         TString createData = Sprintf(
             R"(
@@ -324,7 +338,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
         TestDescribeResult(DescribePath(runtime, "/MyRoot/ServerLess0"),
                            {NLs::PathExist,
                             NLs::IsExternalSubDomain("ServerLess0"),
-                            NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED),
+                            NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared),
                             NLs::ExtractTenantSchemeshard(&tenantSchemeShard)});
 
         UNIT_ASSERT(tenantSchemeShard != 0
@@ -333,7 +347,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
 
         TestDescribeResult(DescribePath(runtime, tenantSchemeShard, "/MyRoot/ServerLess0"),
                            {NLs::PathExist,
-                            NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED)});
+                            NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared)});
         
         auto checkServerlessComputeResourcesMode = [&](EServerlessComputeResourcesMode serverlessComputeResourcesMode) {
             TString alterData = Sprintf(
@@ -353,8 +367,8 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
             env.TestServerlessComputeResourcesModeInHive(runtime, "/MyRoot/ServerLess0", serverlessComputeResourcesMode, sharedHive);
         };
 
-        checkServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED);
-        checkServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED);
+        checkServerlessComputeResourcesMode(EServerlessComputeResourcesModeExclusive);
+        checkServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared);
     }
 
     Y_UNIT_TEST(TestServerlessComputeResourcesModeValidation) {
@@ -421,19 +435,19 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
         // Try to change ServerlessComputeResourcesMode not on serverless database
         TestAlterExtSubDomain(runtime, ++txId,  "/MyRoot",
             R"(
-                ServerlessComputeResourcesMode: SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED
+                ServerlessComputeResourcesMode: EServerlessComputeResourcesModeShared
                 Name: "SharedDB"
             )",
             {{ TEvSchemeShard::EStatus::StatusInvalidParameter, "only for serverless" }}
         );
 
-        // Try to set ServerlessComputeResourcesMode to SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED
+        // Try to set ServerlessComputeResourcesMode to EServerlessComputeResourcesModeUnspecified
         TestAlterExtSubDomain(runtime, ++txId,  "/MyRoot",
             R"(
-                ServerlessComputeResourcesMode: SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED
+                ServerlessComputeResourcesMode: EServerlessComputeResourcesModeUnspecified
                 Name: "ServerLess0"
             )",
-            {{ TEvSchemeShard::EStatus::StatusInvalidParameter, "SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED" }}
+            {{ TEvSchemeShard::EStatus::StatusInvalidParameter, "EServerlessComputeResourcesModeUnspecified" }}
         );
     }
 
@@ -501,7 +515,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLess) {
 
         TestAlterExtSubDomain(runtime, ++txId,  "/MyRoot",
             R"(
-                ServerlessComputeResourcesMode: SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED
+                ServerlessComputeResourcesMode: EServerlessComputeResourcesModeExclusive
                 Name: "ServerLess0"
             )",
             {{ TEvSchemeShard::EStatus::StatusPreconditionFailed, "Unsupported: feature flag EnableServerlessExclusiveDynamicNodes is off" }}
diff --git a/ydb/core/tx/schemeshard/ut_serverless_reboots/ut_serverless_reboots.cpp b/ydb/core/tx/schemeshard/ut_serverless_reboots/ut_serverless_reboots.cpp
index 6238d4488acd..317144fa2529 100644
--- a/ydb/core/tx/schemeshard/ut_serverless_reboots/ut_serverless_reboots.cpp
+++ b/ydb/core/tx/schemeshard/ut_serverless_reboots/ut_serverless_reboots.cpp
@@ -45,80 +45,106 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLessReboots) {
         t.Run([&](TTestActorRuntime& runtime, bool& activeZone) {
             ui64 sharedHive = 0;
             ui64 tenantSchemeShard = 0;
+
+            TestCreateExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
+                R"(Name: "SharedDB")"
+            );
+            t.TestEnv->TestWaitNotification(runtime, t.TxId);
+
+            TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
+                R"(
+                    StoragePools {
+                        Name: "pool-1"
+                        Kind: "pool-kind-1"
+                    }
+                    StoragePools {
+                        Name: "pool-2"
+                        Kind: "pool-kind-2"
+                    }
+                    PlanResolution: 50
+                    Coordinators: 1
+                    Mediators: 1
+                    TimeCastBucketsPerMediator: 2
+                    ExternalSchemeShard: true
+                    ExternalHive: true
+                    Name: "SharedDB"
+                )"
+            );
+            t.TestEnv->TestWaitNotification(runtime, t.TxId);
+
             {
                 TInactiveZone inactive(activeZone);
-                TestCreateExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
-                    R"(Name: "SharedDB")"
-                );
-                t.TestEnv->TestWaitNotification(runtime, t.TxId);
-
-                TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
-                    R"(
-                        StoragePools {
-                            Name: "pool-1"
-                            Kind: "pool-kind-1"
-                        }
-                        StoragePools {
-                            Name: "pool-2"
-                            Kind: "pool-kind-2"
-                        }
-                        PlanResolution: 50
-                        Coordinators: 1
-                        Mediators: 1
-                        TimeCastBucketsPerMediator: 2
-                        ExternalSchemeShard: true
-                        ExternalHive: true
-                        Name: "SharedDB"
-                    )"
-                );
-                t.TestEnv->TestWaitNotification(runtime, t.TxId);
 
+                ui64 sharedDbSchemeShard = 0;
                 TestDescribeResult(DescribePath(runtime, "/MyRoot/SharedDB"),
-                                    {NLs::ExtractDomainHive(&sharedHive)});
-
-                TString createData = Sprintf(
-                    R"(
-                        ResourcesDomainKey {
-                            SchemeShard: %lu
-                            PathId: 3 
-                        }
-                        Name: "ServerLess0"
-                    )",
-                    TTestTxConfig::SchemeShard
-                );
-                TestCreateExtSubDomain(runtime, ++t.TxId,  "/MyRoot", createData);
-                t.TestEnv->TestWaitNotification(runtime, t.TxId);
-
-                TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
-                    R"(
-                        PlanResolution: 50
-                        Coordinators: 1
-                        Mediators: 1
-                        TimeCastBucketsPerMediator: 2
-                        ExternalSchemeShard: true
-                        ExternalHive: false
-                        StoragePools {
-                            Name: "pool-1"
-                            Kind: "pool-kind-1"
-                        }
-                        Name: "ServerLess0"
-                    )"
-                );
-                t.TestEnv->TestWaitNotification(runtime, t.TxId);
+                                    {NLs::PathExist,
+                                     NLs::ExtractTenantSchemeshard(&sharedDbSchemeShard),
+                                     NLs::ExtractDomainHive(&sharedHive),
+                                     NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeUnspecified)});
+                
+                UNIT_ASSERT(sharedHive != 0
+                            && sharedHive != (ui64)-1
+                            && sharedHive != TTestTxConfig::Hive);
+                            
+                UNIT_ASSERT(sharedDbSchemeShard != 0
+                            && sharedDbSchemeShard != (ui64)-1
+                            && sharedDbSchemeShard != TTestTxConfig::SchemeShard);
+                
+                TestDescribeResult(DescribePath(runtime, sharedDbSchemeShard, "/MyRoot/SharedDB"),
+                                    {NLs::PathExist,
+                                     NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeUnspecified)});
+            }
 
+            TString createData = Sprintf(
+                R"(
+                    ResourcesDomainKey {
+                        SchemeShard: %lu
+                        PathId: 3 
+                    }
+                    Name: "ServerLess0"
+                )",
+                TTestTxConfig::SchemeShard
+            );
+            TestCreateExtSubDomain(runtime, ++t.TxId,  "/MyRoot", createData);
+            t.TestEnv->TestWaitNotification(runtime, t.TxId);
+
+            TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
+                R"(
+                    PlanResolution: 50
+                    Coordinators: 1
+                    Mediators: 1
+                    TimeCastBucketsPerMediator: 2
+                    ExternalSchemeShard: true
+                    ExternalHive: false
+                    StoragePools {
+                        Name: "pool-1"
+                        Kind: "pool-kind-1"
+                    }
+                    Name: "ServerLess0"
+                )"
+            );
+            t.TestEnv->TestWaitNotification(runtime, t.TxId);
+                
+            {
+                TInactiveZone inactive(activeZone);
                 TestDescribeResult(DescribePath(runtime, "/MyRoot/ServerLess0"),
                                    {NLs::PathExist,
                                     NLs::IsExternalSubDomain("ServerLess0"),
-                                    NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED),
+                                    NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared),
                                     NLs::ExtractTenantSchemeshard(&tenantSchemeShard)});
+                                    
+                UNIT_ASSERT(tenantSchemeShard != 0
+                            && tenantSchemeShard != (ui64)-1
+                            && tenantSchemeShard != TTestTxConfig::SchemeShard);
+
                 TestDescribeResult(DescribePath(runtime, tenantSchemeShard, "/MyRoot/ServerLess0"),
                                    {NLs::PathExist,
-                                    NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_UNSPECIFIED)});
+                                    NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared)});
             }
 
             TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
                 R"(
-                    ServerlessComputeResourcesMode: SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED
+                    ServerlessComputeResourcesMode: EServerlessComputeResourcesModeExclusive
                     Name: "ServerLess0"
                 )"
             );
@@ -127,16 +153,16 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLessReboots) {
             {
                 TInactiveZone inactive(activeZone);
                 TestDescribeResult(DescribePath(runtime, "/MyRoot/ServerLess0"),
-                                   {NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED)});
+                                   {NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeExclusive)});
                 t.TestEnv->TestServerlessComputeResourcesModeInHive(runtime, "/MyRoot/ServerLess0",
-                                                                    SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED, sharedHive);
+                                                                    EServerlessComputeResourcesModeExclusive, sharedHive);
                 TestTenantSchemeShardSync(t, runtime, tenantSchemeShard, "/MyRoot/ServerLess0",
-                                          ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED));
+                                          ServerlessComputeResourcesMode(EServerlessComputeResourcesModeExclusive));
             }
 
             TestAlterExtSubDomain(runtime, ++t.TxId,  "/MyRoot",
                 R"(
-                    ServerlessComputeResourcesMode: SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED
+                    ServerlessComputeResourcesMode: EServerlessComputeResourcesModeShared
                     Name: "ServerLess0"
                 )"
             );
@@ -145,11 +171,11 @@ Y_UNIT_TEST_SUITE(TSchemeShardServerLessReboots) {
             {
                 TInactiveZone inactive(activeZone);
                 TestDescribeResult(DescribePath(runtime, "/MyRoot/ServerLess0"),
-                                   {NLs::ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED)});
+                                   {NLs::ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared)});
                 t.TestEnv->TestServerlessComputeResourcesModeInHive(runtime, "/MyRoot/ServerLess0",
-                                                                    SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED, sharedHive);
+                                                                    EServerlessComputeResourcesModeShared, sharedHive);
                 TestTenantSchemeShardSync(t, runtime, tenantSchemeShard, "/MyRoot/ServerLess0",
-                                          ServerlessComputeResourcesMode(SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED));
+                                          ServerlessComputeResourcesMode(EServerlessComputeResourcesModeShared));
             }
         });
     }
diff --git a/ydb/tests/functional/serverless/conftest.py b/ydb/tests/functional/serverless/conftest.py
index 314f5f0f433d..d46197139f48 100644
--- a/ydb/tests/functional/serverless/conftest.py
+++ b/ydb/tests/functional/serverless/conftest.py
@@ -119,8 +119,8 @@ def ydb_disk_quoted_serverless_db(ydb_cluster, ydb_root, ydb_hostel_db, ydb_safe
 
 
 @contextlib.contextmanager
-def ydb_serverless_db_with_nodes_ctx(ydb_cluster, database, hostel_db, timeout_seconds=100):
-    logger.info("setup ydb_serverless_db_with_nodes %s using hostel %s", database, hostel_db)
+def ydb_serverless_db_with_exclusive_nodes_ctx(ydb_cluster, database, hostel_db, timeout_seconds=100):
+    logger.info("setup ydb_serverless_db_with_exclusive_nodes %s using hostel %s", database, hostel_db)
 
     ydb_cluster.remove_database(
         database,
@@ -144,7 +144,7 @@ def ydb_serverless_db_with_nodes_ctx(ydb_cluster, database, hostel_db, timeout_s
     try:
         yield database
     finally:
-        logger.info("destroy ydb_serverless_db_with_nodes for %s", database)
+        logger.info("destroy ydb_serverless_db_with_exclusive_nodes for %s", database)
         ydb_cluster.remove_database(
             database,
             timeout_seconds=timeout_seconds
@@ -154,8 +154,8 @@ def ydb_serverless_db_with_nodes_ctx(ydb_cluster, database, hostel_db, timeout_s
 
 
 @pytest.fixture(scope='module')
-def ydb_serverless_db_with_nodes(ydb_cluster, ydb_root, ydb_hostel_db):
-    database_name = os.path.join(ydb_root, "serverless_with_nodes")
+def ydb_serverless_db_with_exclusive_nodes(ydb_cluster, ydb_root, ydb_hostel_db):
+    database_name = os.path.join(ydb_root, "serverless_with_exclusive_nodes")
 
-    with ydb_serverless_db_with_nodes_ctx(ydb_cluster, database_name, ydb_hostel_db):
+    with ydb_serverless_db_with_exclusive_nodes_ctx(ydb_cluster, database_name, ydb_hostel_db):
         yield database_name
diff --git a/ydb/tests/functional/serverless/test_serverless.py b/ydb/tests/functional/serverless/test_serverless.py
index 2659b5db7a62..da0b9109532b 100644
--- a/ydb/tests/functional/serverless/test_serverless.py
+++ b/ydb/tests/functional/serverless/test_serverless.py
@@ -508,7 +508,7 @@ def alter_database_serverless_compute_resources_mode(cluster, database_path, ser
     ydbcli_db_schema_exec(cluster, alter_proto)
 
 
-def test_discovery_dedicated_nodes(ydb_hostel_db, ydb_serverless_db_with_nodes, ydb_endpoint, ydb_cluster):
+def test_discovery_exclusive_nodes(ydb_hostel_db, ydb_serverless_db_with_exclusive_nodes, ydb_endpoint, ydb_cluster):
     def list_endpoints(database):
         logger.debug("List endpoints of %s", database)
 
@@ -524,10 +524,10 @@ def list_endpoints(database):
 
     alter_database_serverless_compute_resources_mode(
         ydb_cluster,
-        ydb_serverless_db_with_nodes,
-        "SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED"
+        ydb_serverless_db_with_exclusive_nodes,
+        "EServerlessComputeResourcesModeShared"
     )
-    serverless_db_shared_endpoints = list_endpoints(ydb_serverless_db_with_nodes)
+    serverless_db_shared_endpoints = list_endpoints(ydb_serverless_db_with_exclusive_nodes)
     hostel_db_endpoints = list_endpoints(ydb_hostel_db)
 
     assert_that(hostel_db_endpoints, not_none())
@@ -536,23 +536,23 @@ def list_endpoints(database):
 
     alter_database_serverless_compute_resources_mode(
         ydb_cluster,
-        ydb_serverless_db_with_nodes,
-        "SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED"
+        ydb_serverless_db_with_exclusive_nodes,
+        "EServerlessComputeResourcesModeExclusive"
     )
-    serverless_db_dedicated_endpoints = list_endpoints(ydb_serverless_db_with_nodes)
+    serverless_db_exclusive_endpoints = list_endpoints(ydb_serverless_db_with_exclusive_nodes)
 
-    assert_that(serverless_db_dedicated_endpoints, not_none())
-    assert_that(serverless_db_dedicated_endpoints, only_contains(not_(is_in(serverless_db_shared_endpoints))))
+    assert_that(serverless_db_exclusive_endpoints, not_none())
+    assert_that(serverless_db_exclusive_endpoints, only_contains(not_(is_in(serverless_db_shared_endpoints))))
 
 
-def test_create_table_using_dedicated_nodes(ydb_hostel_db, ydb_serverless_db_with_nodes, ydb_endpoint, ydb_cluster):
+def test_create_table_using_exclusive_nodes(ydb_serverless_db_with_exclusive_nodes, ydb_endpoint, ydb_cluster):
     alter_database_serverless_compute_resources_mode(
         ydb_cluster,
-        ydb_serverless_db_with_nodes,
-        "SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED"
+        ydb_serverless_db_with_exclusive_nodes,
+        "EServerlessComputeResourcesModeExclusive"
     )
 
-    database = ydb_serverless_db_with_nodes
+    database = ydb_serverless_db_with_exclusive_nodes
     driver_config = ydb.DriverConfig(ydb_endpoint, database)
     driver = ydb.Driver(driver_config)
     driver.wait(120)
@@ -579,20 +579,20 @@ def drop_table(session, path):
                 path
             )
 
-        table_path = os.path.join(dir_path, "create_table_with_dedicated_nodes_table")
+        table_path = os.path.join(dir_path, "create_table_with_exclusive_nodes_table")
         pool.retry_operation_sync(create_table, None, table_path)
         pool.retry_operation_sync(write_some_data, None, table_path)
         pool.retry_operation_sync(drop_table, None, table_path)
 
 
-def test_seamless_migration_to_dedicated_nodes(ydb_hostel_db, ydb_serverless_db_with_nodes, ydb_endpoint, ydb_cluster):
+def test_seamless_migration_to_exclusive_nodes(ydb_serverless_db_with_exclusive_nodes, ydb_endpoint, ydb_cluster):
     alter_database_serverless_compute_resources_mode(
         ydb_cluster,
-        ydb_serverless_db_with_nodes,
-        "SERVERLESS_COMPUTE_RESOURCES_MODE_SHARED"
+        ydb_serverless_db_with_exclusive_nodes,
+        "EServerlessComputeResourcesModeShared"
     )
 
-    database = ydb_serverless_db_with_nodes
+    database = ydb_serverless_db_with_exclusive_nodes
     driver_config = ydb.DriverConfig(ydb_endpoint, database)
     driver = ydb.Driver(driver_config)
     driver.wait(120)
@@ -613,8 +613,8 @@ def test_seamless_migration_to_dedicated_nodes(ydb_hostel_db, ydb_serverless_db_
 
     alter_database_serverless_compute_resources_mode(
         ydb_cluster,
-        ydb_serverless_db_with_nodes,
-        "SERVERLESS_COMPUTE_RESOURCES_MODE_DEDICATED"
+        ydb_serverless_db_with_exclusive_nodes,
+        "EServerlessComputeResourcesModeExclusive"
     )
 
     # Old session keeps work fine with old connections to shared nodes
@@ -628,7 +628,7 @@ def test_seamless_migration_to_dedicated_nodes(ydb_hostel_db, ydb_serverless_db_
     newDriver.wait(120)
     session._driver = newDriver
 
-    # Old session works fine with new connections to dedicated nodes
+    # Old session works fine with new connections to exclusive nodes
     session.transaction().execute(
         f"UPSERT INTO `{path}` (id) VALUES (7), (8), (9);",
         commit_tx=True