diff --git a/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/ActionSequenceExtensionsTests.cs b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/ActionSequenceExtensionsTests.cs
new file mode 100644
index 0000000000..927acdeb74
--- /dev/null
+++ b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/ActionSequenceExtensionsTests.cs
@@ -0,0 +1,262 @@
+#nullable enable
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NUnit.Framework;
+using Xtensive.Modelling.Actions;
+using Xtensive.Modelling.Actions.Extensions;
+using Xtensive.Modelling.Comparison;
+using Xtensive.Modelling.Comparison.Hints;
+using Xtensive.Orm.Upgrade.Model;
+using Xtensive.Sql;
+using Comparer = Xtensive.Modelling.Comparison.Comparer;
+
+namespace Xtensive.Extensions
+{
+  [TestFixture]
+  public class ActionSequenceExtensionsTests
+  {
+    [Test]
+    [TestCaseSource(nameof(AddSecondaryIndexTestCases))]
+    public void ContainsActionsOfType_WhenCreatedIndex_ReturnsExpectedResult(IEnumerable<Type> types, bool expectedResult)
+    {
+      // Arrange
+      var originalStorage = CreateStorage();
+      var originalTable = CreateTable(originalStorage);
+      var originalColumn = AddColumn<string>(originalTable);
+      
+      var actionSequence = GetActionSequence(originalStorage, (storage, _) => {
+        var table = storage.Tables[originalTable.Name];
+        var column = table.Columns[originalColumn.Name];
+        AddSecondaryIndex(column);
+      });
+
+      // Act
+      var result =
+        actionSequence.ContainsActionsOfType<SecondaryIndexInfo>(types);
+      
+      // Assert
+      Assert.AreEqual(result, expectedResult);
+    }
+    
+    [Test]
+    [TestCaseSource(nameof(RemoveSecondaryIndexTestCases))]
+    public void ContainsActionsOfType_WhenRemovedIndex_ReturnsExpectedResult(IEnumerable<Type> types, bool expectedResult)
+    {
+      // Arrange
+      var originalStorage = CreateStorage();
+      var originalTable = CreateTable(originalStorage);
+      var originalColumn = AddColumn<string>(originalTable);
+      var originalIndex = AddSecondaryIndex(originalColumn);
+      
+      var actionSequence = GetActionSequence(originalStorage, (storage, _) => {
+        var table = storage.Tables[originalTable.Name];
+        var index = table.SecondaryIndexes[originalIndex.Name];
+        table.SecondaryIndexes.Remove(index);
+      });
+
+      // Act
+      var result =
+        actionSequence.ContainsActionsOfType<SecondaryIndexInfo>(types);
+      
+      // Assert
+      Assert.AreEqual(result, expectedResult);
+    }
+
+    [Test]
+    [TestCaseSource(nameof(AllActionsTestCaseData))]
+    public void ContainsActionsOfType_WhenChangedOtherNodeThenExpected_ReturnsFalse(Type actionType)
+    {
+      // Arrange
+      var originalStorage = CreateStorage();
+      var originalTable = CreateTable(originalStorage);
+      
+      var actionSequence = GetActionSequence(originalStorage, (storage, _) => {
+        var table = storage.Tables[originalTable.Name];
+        AddColumn<long>(table);
+      });
+
+      // Act
+      var result =
+        actionSequence.ContainsActionsOfType<SecondaryIndexInfo>(new[] { actionType });
+      
+      // Assert
+      Assert.IsFalse(result);
+    }    
+    
+    [Test]
+    [TestCaseSource(nameof(DisallowedStorageChangesTestCaseData))]
+    public void ContainsActionsOfType_WhenDisallowedStorageChangesLogged_ReturnsFalse(Action<StorageModel> action)
+    {
+      // Arrange
+      var originalStorage = CreateStorage();
+      CreateTable(originalStorage);
+      
+      var actionSequence = GetActionSequence(originalStorage, (storage, _) => {
+        action(storage);
+      });
+
+      // Act
+      var result =
+        actionSequence.ContainsActionsOfType<SecondaryIndexInfo>(new[] {
+          typeof(CreateNodeAction), typeof(RemoveNodeAction)
+        });
+      
+      // Assert
+      Assert.IsFalse(result);
+    }
+    
+    [Test]
+    [TestCaseSource(nameof(DisallowedTableChangesTestCaseData))]
+    public void ContainsActionsOfType_WhenDisallowedTableActionsLogged_ReturnsFalse(Action<TableInfo> action)
+    {
+      // Arrange
+      var originalStorage = CreateStorage();
+      var originalTable = CreateTable(originalStorage);
+      AddColumn<long>(originalTable);
+      AddColumn<string>(originalTable);
+      
+      var actionSequence = GetActionSequence(originalStorage, (storage, _) => {
+        var table = storage.Tables[originalTable.Name];
+        action(table);
+      });
+
+      // Act
+      var result =
+        actionSequence.ContainsActionsOfType<SecondaryIndexInfo>(new[] {
+          typeof(CreateNodeAction), typeof(RemoveNodeAction)
+        });
+      
+      // Assert
+      Assert.IsFalse(result);
+    }
+
+    private static StorageModel CreateStorage() => new("storage");
+
+    private static TableInfo CreateTable(StorageModel storageInfo)
+    {
+      var table = new TableInfo(storageInfo, Guid.NewGuid().ToString());
+      var id = new StorageColumnInfo(table, "Id", new StorageTypeInfo(typeof (int), new SqlValueType(SqlType.Int32)));
+      var pk = new PrimaryIndexInfo(table, "PK_A");
+      _ = new KeyColumnRef(pk, id);
+      pk.PopulateValueColumns();
+
+      return table;
+    }
+
+    private static StorageColumnInfo AddColumn<TType>(TableInfo table, string? name = null)
+    {
+      var column = new StorageColumnInfo(table, name ?? Guid.NewGuid().ToString(),
+        new StorageTypeInfo(typeof(TType), new SqlValueType(typeof(TType).Name), false));
+
+      var pk = table.PrimaryIndex;
+      pk.ValueColumns.Clear();
+      pk.PopulateValueColumns();
+
+      return column;
+    }
+
+    private static SecondaryIndexInfo AddSecondaryIndex(params StorageColumnInfo[] columns)
+    {
+      var table = columns[0].Parent;
+      var index = new SecondaryIndexInfo(table, $"index{Guid.NewGuid()}");
+
+      foreach (var column in columns) {
+        _ = new KeyColumnRef(index, column);
+      }
+      index.PopulatePrimaryKeyColumns();
+
+      return index;
+    }
+    
+    private static ActionSequence GetActionSequence(StorageModel origin, Action<StorageModel, HintSet> mutator)
+    {
+      var clonedStorage = Clone(origin);
+      var hints = new HintSet(origin, clonedStorage);
+      mutator.Invoke(clonedStorage, hints);
+      origin.Validate();
+      clonedStorage.Validate();
+
+      var comparer = new Comparer();
+      var diff = comparer.Compare(origin, clonedStorage, hints);
+      return new ActionSequence() {
+        new Upgrader().GetUpgradeSequence(diff, hints, comparer)
+      };
+    }
+
+    private static StorageModel Clone(StorageModel storage) => (StorageModel) storage.Clone(null, storage.Name);
+
+    private static readonly IEnumerable<Type> AllNodeActionsBesidesGroup = Assembly.GetAssembly(typeof(NodeAction))!
+      .DefinedTypes
+      .Where(type => type.IsSubclassOf(typeof(NodeAction))).Except(new[] { typeof(GroupingNodeAction) });
+
+    private static readonly IEnumerable<Type> AllActionBesidesCreateAndRemove =
+      AllNodeActionsBesidesGroup.Except(new[] { typeof(CreateNodeAction), typeof(RemoveNodeAction) });
+    
+    public static IEnumerable AddSecondaryIndexTestCases
+    {
+      get {
+        yield return new TestCaseData(new object?[] { new [] { typeof(CreateNodeAction) }, true });
+        yield return new TestCaseData(new object?[] { new [] { typeof(RemoveNodeAction) }, false });
+        yield return new TestCaseData(new object?[] { new [] { typeof(CreateNodeAction), typeof(RemoveNodeAction) }, true });
+        yield return new TestCaseData(new object?[] { AllActionBesidesCreateAndRemove, false });
+      }
+    }
+    
+    public static IEnumerable RemoveSecondaryIndexTestCases
+    {
+      get {
+        yield return new TestCaseData(new object?[] { new [] { typeof(CreateNodeAction) }, false });
+        yield return new TestCaseData(new object?[] { new [] { typeof(RemoveNodeAction) }, true });
+        yield return new TestCaseData(new object?[] { new [] { typeof(CreateNodeAction), typeof(RemoveNodeAction) }, true });
+        yield return new TestCaseData(new object?[] { AllActionBesidesCreateAndRemove, false });
+      }
+    }
+    
+    
+    public static IEnumerable AllActionsTestCaseData => AllNodeActionsBesidesGroup.Select(actionType => new TestCaseData(actionType));
+
+    public static IEnumerable DisallowedStorageChangesTestCaseData
+    {
+      get {
+        yield return new TestCaseData(new object?[] { new Action<StorageModel>(storageInfo => CreateTable(storageInfo)) });
+        yield return new TestCaseData(new object?[] { new Action<StorageModel>(storageInfo => storageInfo.Tables.First().Remove()) });
+      }
+    }
+    
+    public static IEnumerable DisallowedTableChangesTestCaseData
+    {
+      get {
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => table.PrimaryIndex.Remove()) });
+        // TODO: possibly not supported
+        // yield return new TestCaseData(new object?[] {
+        //   new Action<TableInfo>(table => {
+        //     table.PrimaryIndex.KeyColumns.First().Remove();
+        //     new KeyColumnRef(table.PrimaryIndex, table.Columns.Last());
+        //     table.PrimaryIndex.ValueColumns.Clear();
+        //     table.PrimaryIndex.PopulateValueColumns();
+        //   })
+        // });
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => table.PrimaryIndex.Name = $"OtherName{Guid.NewGuid() }") });
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => AddColumn<string>(table)) });
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => {
+          table.Columns.Last().Remove();
+          table.PrimaryIndex.ValueColumns.Clear();
+          table.PrimaryIndex.PopulateValueColumns();
+        }) });
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => table.Columns.Last().Name = $"OtherName{Guid.NewGuid()}") });
+        // TODO: DefaultValue is marked as IgnoreInComparison
+        //yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => table.Columns.Last(c => c.Type.Type == typeof(string)).DefaultValue = $"") });
+        yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => table.Columns.Last().Type = new StorageTypeInfo(typeof(byte), new SqlValueType(SqlType.Int8))) });
+        // TODO: seems like index change not handled in upgrade
+        // yield return new TestCaseData(new object?[] { new Action<TableInfo>(table => {
+        //   table.Columns.Last().Index -= 1;
+        //   table.PrimaryIndex.ValueColumns.Clear();
+        //   table.PrimaryIndex.PopulateValueColumns();
+        // }) });
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/MyEntity.cs b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/MyEntity.cs
new file mode 100644
index 0000000000..57ebf8d13e
--- /dev/null
+++ b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/MyEntity.cs
@@ -0,0 +1,71 @@
+#nullable enable
+using System;
+using System.Linq.Expressions;
+
+namespace Xtensive.Orm.Tests.Upgrade.SyncIndexes
+{
+
+  namespace V1
+  {
+    [HierarchyRoot]
+    public class MyEntity : Entity
+    {
+      [Key, Field]
+      public long Id { get; set; }
+      
+      [Field]
+      public string? Name { get; set; }
+      
+      [Field]
+      public long Value { get; set; }
+      
+      [Field]
+      public long Count { get; set; }
+    }
+  }
+  
+  namespace V2
+  {
+    [Index(nameof(Value), Filter = nameof(CountIs), Name = "IX_Value")]
+    [Index(nameof(Count))]
+    [HierarchyRoot]
+    public class MyEntity : Entity
+    {
+      private static Expression<Func<MyEntity, bool>> CountIs() => e => e.Count == 1;
+
+      [Key, Field]
+      public long Id { get; set; }
+      
+      [Field]
+      public string? Name { get; set; }
+      
+      [Field]
+      public long Value { get; set; }
+      
+      [Field]
+      public long Count { get; set; }
+    }
+  }
+  
+  namespace V3
+  {
+    [Index(nameof(Value), Filter = nameof(CountIs), Name = "IX_Value")]
+    [HierarchyRoot]
+    public class MyEntity : Entity
+    {
+      private static Expression<Func<MyEntity, bool>> CountIs() => e => e.Count1 == 1;
+
+      [Key, Field] 
+      public long Id { get; set; }
+      
+      [Field]
+      public string? Name { get; set; }
+
+      [Field] 
+      public long Value { get; set; }
+
+      [Field] 
+      public long Count1 { get; set; }
+    }
+  }
+}
diff --git a/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/SyncIndexesTests.cs b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/SyncIndexesTests.cs
new file mode 100644
index 0000000000..c05875eb46
--- /dev/null
+++ b/Orm/Xtensive.Orm.Tests/Upgrade/SyncIndexes/SyncIndexesTests.cs
@@ -0,0 +1,66 @@
+using System;
+using NUnit.Framework;
+using Xtensive.Orm.Configuration;
+
+namespace Xtensive.Orm.Tests.Upgrade.SyncIndexes
+{
+  public class SyncIndexesTests
+  {
+
+    [Test]
+    public void BuildDomainWithSyncIndexMode_WhenOnlyIndexesAdded_ShouldSuccessfullyBuild()
+    {
+      // Arrange
+      CreateDomain(typeof(V1.MyEntity));
+
+      // Act
+      Action action = () => SyncIndexes(typeof(V2.MyEntity));
+      
+      // Assert
+      Assert.DoesNotThrow(() => action());
+    }
+    
+    [Test]
+    public void BuildDomainWithSyncIndexMode_WhenOnlyIndexesRemoved_ShouldSuccessfullyBuild()
+    {
+      // Arrange
+      CreateDomain(typeof(V2.MyEntity));
+
+      // Act
+      Action action = () => SyncIndexes(typeof(V1.MyEntity));
+      
+      // Assert
+      Assert.DoesNotThrow(() => action());
+    }
+    
+    [Test]
+    public void BuildDomainWithSyncIndexMode_WhenSchemaChanged_ShouldSuccessfullyBuild()
+    {
+      // Arrange
+      CreateDomain(typeof(V2.MyEntity));
+
+      // Act
+      Action action = () => SyncIndexes(typeof(V3.MyEntity));
+      
+      // Assert
+      Assert.Throws<SchemaSynchronizationException>(() => action());
+    }
+    
+    private static void CreateDomain(Type sampleType) => BuildDomain(DomainUpgradeMode.Recreate, sampleType);
+    private static void SyncIndexes(Type sampleType) => BuildDomain(DomainUpgradeMode.SyncIndexesSafely, sampleType);
+
+    private static void BuildDomain(DomainUpgradeMode upgradeMode, Type sampleType)
+    {
+      var configuration = BuildDomainConfiguration(upgradeMode, sampleType);
+      Domain.Build(configuration);
+    }
+
+    private static DomainConfiguration BuildDomainConfiguration(DomainUpgradeMode upgradeMode, Type sampleType)
+    {
+      var configuration = DomainConfigurationFactory.Create();
+      configuration.UpgradeMode = upgradeMode;
+      configuration.Types.Register(sampleType.Assembly, sampleType.Namespace);
+      return configuration;
+    }
+  }
+}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm/Modelling/Actions/Extensions/ActionSequenceExtensions.cs b/Orm/Xtensive.Orm/Modelling/Actions/Extensions/ActionSequenceExtensions.cs
new file mode 100644
index 0000000000..5ff38af2f7
--- /dev/null
+++ b/Orm/Xtensive.Orm/Modelling/Actions/Extensions/ActionSequenceExtensions.cs
@@ -0,0 +1,91 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xtensive.Modelling.Comparison;
+
+namespace Xtensive.Modelling.Actions.Extensions
+{
+  public static class ActionSequenceExtensions
+  {
+    private static readonly Type[] ModificationActions = new[] { typeof(CreateNodeAction), typeof(RemoveNodeAction) };
+
+    /// <summary>
+    /// Checks if all actions within the <see cref="IActionSequence"/> exclusively involve modifications of the specified subject type.
+    /// </summary>
+    /// <typeparam name="TSubjectType">The subject type for which modifications are checked.</typeparam>
+    /// <param name="actionSequence">The sequence of actions to check.</param>
+    /// <returns>True if the sequence contains only actions related to the creation or removal of nodes of the specified target type; otherwise, false.</returns>
+    public static bool ContainsOnlyModificationOf<TSubjectType>(this IActionSequence actionSequence) =>
+      ContainsActionsOfType<TSubjectType>(actionSequence, ModificationActions);
+    
+    /// <summary>
+    /// Checks if all actions within the <see cref="IActionSequence"/> are allowed for differences of the specified type.
+    /// </summary>
+    /// <typeparam name="TSubjectType">The subject type to check for in the differences associated with the actions.</typeparam>
+    /// <param name="actionSequence">The sequence of actions to check.</param>
+    /// <param name="types">A collection of types to compare with the types of the associated differences.</param>
+    /// <returns>True if all actions are allowed for differences of the specified type; otherwise, false.</returns>
+    public static bool ContainsActionsOfType<TSubjectType>(this IActionSequence actionSequence, IEnumerable<Type> types) =>
+      actionSequence.Flatten().All(action => action.IsActionAllowedForDifference<TSubjectType>(types));
+    
+    /// <summary>
+    /// Determines whether the specified action is allowed for a difference of the specified type.
+    /// </summary>
+    /// <typeparam name="TSubjectType">The subject type to check for in the difference.</typeparam>
+    /// <param name="nodeAction">The <see cref="INodeAction"/> instance associated with the action.</param>
+    /// <param name="types">A collection of types to compare with the type of the node action.</param>
+    /// <returns>True if the action is allowed for a difference of the specified type; otherwise, false.</returns>
+    private static bool IsActionAllowedForDifference<TSubjectType>(this INodeAction nodeAction, IEnumerable<Type> types)
+    {
+      if (nodeAction.Difference is null) {
+        return false;
+      }
+
+      var isNodeActionOfType = types.Contains(nodeAction.GetType());
+
+      return nodeAction.Difference.IsAllowedForSubject<TSubjectType>(isNodeActionOfType,
+               static difference => difference?.Target) ||
+             nodeAction.Difference.IsAllowedForSubject<TSubjectType>(isNodeActionOfType,
+               static difference => difference?.Source);
+    }
+    
+    /// <summary>
+    /// Determines whether the given <see cref="IDifference"/> is allowed for a subject of the specified type.
+    /// </summary>
+    /// <typeparam name="TSubjectType">The subject type to check for in the subject.</typeparam>
+    /// <param name="difference">The current difference.</param>
+    /// <param name="isNodeActionOfType">A flag indicating if the action type of the node matches the specified type.</param>
+    /// <param name="subject">A function to extract the subject of type <see cref="object"/> from the difference.</param>
+    /// <returns>True if the difference is allowed for the specified subject type; otherwise, checks the parent chain and returns true if the type is found, otherwise false.</returns>
+    private static bool IsAllowedForSubject<TSubjectType>(this IDifference difference,
+      bool isNodeActionOfType,
+      Func<IDifference?, object?> subject) =>
+      (isNodeActionOfType && subject(difference) is TSubjectType) || difference.IsParentTargetOfType<TSubjectType>(subject);
+
+    /// <summary>
+    /// Checks whether the parent chain of the given <see cref="IDifference"/> contains a target of the specified type.
+    /// </summary>
+    /// <typeparam name="TSubjectType">The subject type to check for in the parent chain.</typeparam>
+    /// <param name="difference">The current difference.</param>
+    /// <param name="diffSubject">A function to extract the subject of type <see cref="object"/> from the parent difference.</param>
+    /// <returns>True if a target of the specified type is found in the parent chain; otherwise, false.</returns>
+    private static bool IsParentTargetOfType<TSubjectType>(this IDifference difference, Func<IDifference?, object?> diffSubject)
+    {
+      var parentDifference = difference.Parent;
+      
+      var subject = diffSubject(parentDifference);
+      
+      while (subject is not null) {
+        if (subject is TSubjectType) {
+          return true;
+        }
+      
+        parentDifference = parentDifference.Parent;
+        subject = diffSubject(parentDifference);
+      }
+
+      return false;
+    }
+  }
+}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm/Orm/DomainUpgradeMode.cs b/Orm/Xtensive.Orm/Orm/DomainUpgradeMode.cs
index f99b4375a9..40945353e6 100644
--- a/Orm/Xtensive.Orm/Orm/DomainUpgradeMode.cs
+++ b/Orm/Xtensive.Orm/Orm/DomainUpgradeMode.cs
@@ -67,6 +67,12 @@ public enum DomainUpgradeMode
     /// from the expected one.
     /// </summary>
     LegacyValidate = 6,
+    
+    /// <summary>
+    /// Missing non-clustered indexes will be added,
+    /// unmapped non-clustered indexes will be removed, 
+    /// </summary>
+    SyncIndexesSafely = 7,
 
     /// <summary>
     /// Default upgrade mode.
diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/DomainUpgradeModeExtensions.cs b/Orm/Xtensive.Orm/Orm/Upgrade/DomainUpgradeModeExtensions.cs
index 2c5b3ac165..71e1428662 100644
--- a/Orm/Xtensive.Orm/Orm/Upgrade/DomainUpgradeModeExtensions.cs
+++ b/Orm/Xtensive.Orm/Orm/Upgrade/DomainUpgradeModeExtensions.cs
@@ -61,6 +61,7 @@ public static bool IsUpgrading(this DomainUpgradeMode upgradeMode)
       case DomainUpgradeMode.Perform:
       case DomainUpgradeMode.PerformSafely:
       case DomainUpgradeMode.Recreate:
+      case DomainUpgradeMode.SyncIndexesSafely:
         return true;
       default:
         return false;
@@ -80,6 +81,8 @@ internal static SqlWorkerTask GetSqlWorkerTask(this DomainUpgradeMode upgradeMod
         return SqlWorkerTask.ExtractSchema | SqlWorkerTask.DropSchema;
       case DomainUpgradeMode.LegacySkip:
       case DomainUpgradeMode.LegacyValidate:
+        // TODO: check
+      case DomainUpgradeMode.SyncIndexesSafely:
         return SqlWorkerTask.ExtractSchema;
       default:
         throw new ArgumentOutOfRangeException("upgradeMode");
@@ -93,6 +96,8 @@ internal static SchemaUpgradeMode GetUpgradingStageUpgradeMode(this DomainUpgrad
         return SchemaUpgradeMode.PerformSafely;
       case DomainUpgradeMode.Perform:
         return SchemaUpgradeMode.Perform;
+      case DomainUpgradeMode.SyncIndexesSafely:
+        return SchemaUpgradeMode.SyncIndexesSafely;
       default:
         throw new ArgumentOutOfRangeException("upgradeMode");
       }
@@ -116,6 +121,8 @@ internal static SchemaUpgradeMode GetFinalStageUpgradeMode(this DomainUpgradeMod
         // there may be some recycled columns/tables.
         // Perform will wipe them out.
         return SchemaUpgradeMode.Perform;
+      case DomainUpgradeMode.SyncIndexesSafely:
+        return SchemaUpgradeMode.SyncIndexesSafely;
       default:
         throw new ArgumentOutOfRangeException("upgradeMode");
       }
diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/SchemaUpgradeMode.cs b/Orm/Xtensive.Orm/Orm/Upgrade/SchemaUpgradeMode.cs
index 57f0261ce6..e45da50fd7 100644
--- a/Orm/Xtensive.Orm/Orm/Upgrade/SchemaUpgradeMode.cs
+++ b/Orm/Xtensive.Orm/Orm/Upgrade/SchemaUpgradeMode.cs
@@ -46,5 +46,10 @@ public enum SchemaUpgradeMode
     /// Skip schema upgrade.
     /// </summary>
     Skip,
+    
+    /// <summary>
+    /// Update only non-clustered indexes.
+    /// </summary>
+    SyncIndexesSafely,
   }
 }
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs
index 4c2d1c1003..33821e7b3a 100644
--- a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs
+++ b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs
@@ -13,6 +13,8 @@
 using System.Threading.Tasks;
 using Xtensive.Core;
 using Xtensive.IoC;
+using Xtensive.Modelling.Actions;
+using Xtensive.Modelling.Actions.Extensions;
 using Xtensive.Modelling.Comparison;
 using Xtensive.Modelling.Comparison.Hints;
 using Xtensive.Orm.Building.Builders;
@@ -618,6 +620,10 @@ private void SynchronizeSchema(
             if (result.IsCompatibleInLegacyMode!=true)
               throw new SchemaSynchronizationException(result);
             break;
+          case SchemaUpgradeMode.SyncIndexesSafely:
+            if (!result.UpgradeActions.ContainsOnlyModificationOf<SecondaryIndexInfo>()) 
+              throw new SchemaSynchronizationException(result);
+            goto case SchemaUpgradeMode.PerformSafely;
           default:
             throw new ArgumentOutOfRangeException("schemaUpgradeMode");
         }
@@ -705,6 +711,10 @@ await upgrader.UpgradeSchemaAsync(
             if (result.IsCompatibleInLegacyMode!=true)
               throw new SchemaSynchronizationException(result);
             break;
+          case SchemaUpgradeMode.SyncIndexesSafely:
+            if (!result.UpgradeActions.ContainsOnlyModificationOf<SecondaryIndexInfo>())
+              throw new SchemaSynchronizationException(result);
+            goto case SchemaUpgradeMode.PerformSafely;
           default:
             throw new ArgumentOutOfRangeException(nameof(schemaUpgradeMode));
         }