diff --git a/src/java/org/apache/cassandra/cql3/restrictions/StatementRestrictions.java b/src/java/org/apache/cassandra/cql3/restrictions/StatementRestrictions.java
index ac49d7d6f694..435787270158 100644
--- a/src/java/org/apache/cassandra/cql3/restrictions/StatementRestrictions.java
+++ b/src/java/org/apache/cassandra/cql3/restrictions/StatementRestrictions.java
@@ -778,6 +778,17 @@ public boolean hasIndxBasedOrdering()
         return nonPrimaryKeyRestrictions.restrictions().stream().anyMatch(SingleRestriction::isIndexBasedOrdering);
     }
 
+    public boolean hasIndxBasedBoundedAnn()
+    {
+        for (SingleRestriction restriction : nonPrimaryKeyRestrictions.restrictions())
+        {
+            if (restriction.isBoundedAnn())
+                return true;
+        }
+
+        return false;
+    }
+
     public void throwRequiresAllowFilteringError(TableMetadata table)
     {
         if (hasIndxBasedOrdering())
@@ -994,7 +1005,7 @@ private boolean hasUnrestrictedClusteringColumns()
         return table.clusteringColumns().size() != clusteringColumnsRestrictions.size();
     }
 
-    public RowFilter getRowFilter(IndexRegistry indexManager, QueryOptions options, QueryState queryState, SelectOptions selectOptions)
+    public RowFilter getRowFilter(IndexRegistry indexManager, QueryOptions options, QueryState queryState, SelectOptions selectOptions, boolean allowFiltering)
     {
         boolean hasAnnOptions = selectOptions.hasANNOptions();
 
@@ -1007,7 +1018,14 @@ public RowFilter getRowFilter(IndexRegistry indexManager, QueryOptions options,
         }
 
         ANNOptions annOptions = selectOptions.parseANNOptions();
-        RowFilter rowFilter = RowFilter.builder(indexManager)
+
+        // Ordering on non-clustering column requires each restricted column to be indexed except for
+        // fully-specified partition keys. ANN queries do not currently work correctly when filtering is required, so we
+        // fail even though ALLOW FILTERING was passed.
+        if (allowFiltering && (hasIndxBasedOrdering() || hasIndxBasedBoundedAnn()))
+            allowFiltering = false;
+
+        RowFilter rowFilter = RowFilter.builder(indexManager, allowFiltering)
                                        .buildFromRestrictions(this, table, options, queryState, annOptions);
 
         if (hasAnnOptions && !rowFilter.hasANN())
diff --git a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
index ace05ee3545f..f3e254de68e4 100644
--- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
+++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
@@ -1008,7 +1008,7 @@ private NavigableSet<Clustering<?>> getRequestedRows(QueryOptions options, Query
     public RowFilter getRowFilter(QueryOptions options, QueryState state) throws InvalidRequestException
     {
         IndexRegistry indexRegistry = IndexRegistry.obtain(table);
-        return restrictions.getRowFilter(indexRegistry, options, state, selectOptions);
+        return restrictions.getRowFilter(indexRegistry, options, state, selectOptions, parameters.allowFiltering);
     }
 
     private ResultSet process(PartitionIterator partitions,
diff --git a/src/java/org/apache/cassandra/db/ReadCommand.java b/src/java/org/apache/cassandra/db/ReadCommand.java
index 7fa00f0436e5..0910d0f76c24 100644
--- a/src/java/org/apache/cassandra/db/ReadCommand.java
+++ b/src/java/org/apache/cassandra/db/ReadCommand.java
@@ -18,12 +18,7 @@
 package org.apache.cassandra.db;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
 import java.util.function.Function;
@@ -64,7 +59,6 @@
 import org.apache.cassandra.guardrails.Guardrails;
 import org.apache.cassandra.guardrails.Threshold;
 import org.apache.cassandra.index.Index;
-import org.apache.cassandra.index.IndexRegistry;
 import org.apache.cassandra.io.IVersionedSerializer;
 import org.apache.cassandra.io.sstable.format.SSTableReader;
 import org.apache.cassandra.io.util.DataInputPlus;
@@ -90,13 +84,14 @@
 import static com.google.common.collect.Iterables.any;
 import static com.google.common.collect.Iterables.filter;
 import static org.apache.cassandra.db.partitions.UnfilteredPartitionIterators.MergeListener.NOOP;
+import static org.apache.cassandra.index.SecondaryIndexManager.getIndexStatus;
 import static org.apache.cassandra.utils.MonotonicClock.approxTime;
 
 /**
  * General interface for storage-engine read commands (common to both range and
  * single partition commands).
  * <p>
- * This contains all the informations needed to do a local read.
+ * This contains all the information needed to do a local read.
  */
 public abstract class ReadCommand extends AbstractReadQuery
 {
@@ -216,7 +211,7 @@ public int digestVersion()
      * this allows us to use the command as a carrier of the digest version even if we only call
      * setIsDigestQuery on some copy of it.
      *
-     * @param digestVersion the version for the digest is this command is used for digest query..
+     * @param digestVersion the version for the digest is this command is used for digest query.
      * @return this read command.
      */
     public ReadCommand setDigestVersion(int digestVersion)
@@ -405,9 +400,8 @@ public UnfilteredPartitionIterator executeLocally(ReadExecutionController execut
         ColumnFamilyStore cfs = Keyspace.openAndGetStore(metadata());
 
         Index.Searcher searcher = null;
-        if (indexQueryPlan != null)
+        if (indexQueryPlan != null && cfs.indexManager.searcherFor(indexQueryPlan, rowFilter().allowFiltering))
         {
-            cfs.indexManager.checkQueryability(indexQueryPlan);
             searcher = indexSearcher();
             Index index = indexQueryPlan.getFirst();
             Tracing.trace("Executing read on {}.{} using index {}", cfs.metadata.keyspace, cfs.metadata.name, index.getIndexMetadata().name);
@@ -530,9 +524,9 @@ public ReadExecutionController executionController(boolean trackRepairedStatus)
     }
 
     /**
-     * Allow to post-process the result of the query after it has been reconciled on the coordinator
+     * Allow to post-process the result of the query after it has been reconciled on the coordinator,
      * but before it is passed to the CQL layer to return the ResultSet.
-     *
+     * <p>
      * See CASSANDRA-8717 for why this exists.
      */
     public PartitionIterator postReconciliationProcessing(PartitionIterator result)
@@ -740,7 +734,7 @@ public Message<ReadCommand> createMessage(boolean trackRepairedData)
 
     // Skip purgeable tombstones. We do this because it's safe to do (post-merge of the memtable and sstable at least), it
     // can save us some bandwith, and avoid making us throw a TombstoneOverwhelmingException for purgeable tombstones (which
-    // are to some extend an artefact of compaction lagging behind and hence counting them is somewhat unintuitive).
+    // are to some extent an artefact of compaction lagging behind and hence counting them is somewhat unintuitive).
     protected UnfilteredPartitionIterator withoutPurgeableTombstones(UnfilteredPartitionIterator iterator,
                                                                      ColumnFamilyStore cfs,
                                                                      ReadExecutionController controller)
@@ -768,7 +762,7 @@ protected LongPredicate getPurgeEvaluator()
      * Note that in general the returned string will not be exactly the original user string, first
      * because there isn't always a single syntax for a given query,  but also because we don't have
      * all the information needed (we know the non-PK columns queried but not the PK ones as internally
-     * we query them all). So this shouldn't be relied too strongly, but this should be good enough for
+     * we query them all). So this shouldn't be relied on too strongly, but this should be good enough for
      * debugging purpose which is what this is for.
      */
     public String toCQLString()
@@ -832,7 +826,7 @@ InputCollector<UnfilteredPartitionIterator> iteratorsForRange(ColumnFamilyStore.
      * input for a query. Separates them according to repaired status and of repaired
      * status is being tracked, handles the merge and wrapping in a digest generator of
      * the repaired iterators.
-     *
+     * <p>
      * Intentionally not AutoCloseable so we don't mistakenly use this in ARM blocks
      * as this prematurely closes the underlying iterators
      */
@@ -1040,7 +1034,7 @@ public ReadCommand deserialize(DataInputPlus in, int version) throws IOException
             int flags = in.readByte();
             boolean isDigest = isDigest(flags);
             boolean acceptsTransient = acceptsTransient(flags);
-            // Shouldn't happen or it's a user error (see comment above) but
+            // Shouldn't happen, or it's a user error (see comment above) but
             // better complain loudly than doing the wrong thing.
             if (isForThrift(flags))
                 throw new IllegalStateException("Received a command with the thrift flag set. "
@@ -1072,17 +1066,62 @@ public ReadCommand deserialize(DataInputPlus in, int version) throws IOException
             if (hasIndex)
             {
                 IndexMetadata index = deserializeIndexMetadata(in, version, metadata);
-                if (index != null)
-                {
-                    Index.Group indexGroup = Keyspace.openAndGetStore(metadata).indexManager.getIndexGroup(index);
-                    if (indexGroup != null)
-                        indexQueryPlan = indexGroup.queryPlanFor(rowFilter);
-                }
+                indexQueryPlan = buildIndexQueryPlan(index, metadata, rowFilter);
             }
 
             return kind.selectionDeserializer.deserialize(in, version, isDigest, digestVersion, acceptsTransient, metadata, nowInSec, columnFilter, rowFilter, limits, indexQueryPlan);
         }
 
+        /**
+         * Builds a query plan for the specified index, considering index availability and status.
+         * 
+         * @param index The index metadata to build the plan for
+         * @param metadata The table metadata that contains the index
+         * @param rowFilter The row filter to be applied in the query
+         * @return A query plan that uses available indexes, or null if:
+         *         - the provided index is null
+         *         - no index group is found for the index
+         *         - no query plan could be created for the row filter
+         *         - all indexes are in INITIAL_BUILD_STARTED state and not queryable
+         * <p>
+         * If some indexes are in INITIAL_BUILD_STARTED state but others are available, 
+         * returns a new query plan using only the available indexes.
+         */
+        private static Index.QueryPlan buildIndexQueryPlan(IndexMetadata index, TableMetadata metadata, RowFilter rowFilter)
+        {
+            if (index == null)
+                return null;
+
+            Index.Group indexGroup = Keyspace.openAndGetStore(metadata).indexManager.getIndexGroup(index);
+            if (indexGroup == null)
+                return null;
+
+            Index.QueryPlan queryPlan = indexGroup.queryPlanFor(rowFilter);
+            if (queryPlan == null)
+                return null;
+
+            Set<Index> allIndexes = queryPlan.getIndexes();
+            Set<Index> availableIndexes = new HashSet<>();
+
+            for (Index plannedIndex : allIndexes)
+            {
+                String indexName = plannedIndex.getIndexMetadata().name;
+                Index.Status status = getIndexStatus(FBUtilities.getBroadcastAddressAndPort(),
+                                                     metadata.keyspace,
+                                                     indexName);
+
+                if (status != Index.Status.INITIAL_BUILD_STARTED && plannedIndex.isQueryable(status))
+                    availableIndexes.add(plannedIndex);
+            }
+
+            if (availableIndexes.isEmpty())
+                return null;
+
+            return availableIndexes.size() < allIndexes.size()
+                   ? indexGroup.queryPlanForIndices(rowFilter, availableIndexes)
+                   : queryPlan;
+        }
+
         private @Nullable IndexMetadata deserializeIndexMetadata(DataInputPlus in, int version, TableMetadata metadata) throws IOException
         {
             try
diff --git a/src/java/org/apache/cassandra/db/filter/ANNOptions.java b/src/java/org/apache/cassandra/db/filter/ANNOptions.java
index 68bf14417f09..37db98547b2a 100644
--- a/src/java/org/apache/cassandra/db/filter/ANNOptions.java
+++ b/src/java/org/apache/cassandra/db/filter/ANNOptions.java
@@ -37,6 +37,9 @@
  */
 public class ANNOptions
 {
+    public static final String REQUIRES_HIGHER_MESSAGING_VERSION =
+    "ANN options are not supported in clusters below DS 11.";
+
     public static final String RERANK_K_OPTION_NAME = "rerank_k";
 
     public static final ANNOptions NONE = new ANNOptions(null);
@@ -81,7 +84,7 @@ public void validate(QueryState state, String keyspace, int limit)
         if (MessagingService.current_version < MessagingService.VERSION_DS_11)
             badNodes.add(FBUtilities.getBroadcastAddressAndPort());
         if (!badNodes.isEmpty())
-            throw new InvalidRequestException("ANN options are not supported in clusters below DS 11.");
+            throw new InvalidRequestException(REQUIRES_HIGHER_MESSAGING_VERSION);
     }
 
     /**
diff --git a/src/java/org/apache/cassandra/db/filter/RowFilter.java b/src/java/org/apache/cassandra/db/filter/RowFilter.java
index 4d35566fa41f..e330e987c3ad 100644
--- a/src/java/org/apache/cassandra/db/filter/RowFilter.java
+++ b/src/java/org/apache/cassandra/db/filter/RowFilter.java
@@ -79,13 +79,44 @@ public class RowFilter
     private static final Logger logger = LoggerFactory.getLogger(RowFilter.class);
 
     public static final Serializer serializer = new Serializer();
-    public static final RowFilter NONE = new RowFilter(FilterElement.NONE);
+    public static final RowFilter NONE = new RowFilter(FilterElement.NONE, false);
 
     private final FilterElement root;
 
-    protected RowFilter(FilterElement root)
+    /**
+     * Indicates whether ALLOW FILTERING was specified in the CQL query and whether the respective type of query allows
+     * the query to be executed when using ALLOW FILTERING.
+     * <p>
+     * By default, CQL only allows queries that can be executed efficiently by:
+     * - Using the primary key
+     * - Using a secondary index
+     * - Scanning all data when no WHERE clause is present
+     * <p>
+     * When a query requires filtering data that cannot be handled efficiently (e.g., filtering on a non-indexed column),
+     * CQL will reject it unless ALLOW FILTERING is specified. This is because such queries may need to scan large amounts
+     * of data to return a small result set, leading to unpredictable performance.
+     * <p>
+     * For example, given a table:
+     * CREATE TABLE users (username text PRIMARY KEY, birth_year int, country text);
+     * CREATE INDEX ON users(birth_year);
+     * <p>
+     * These queries are allowed by default:
+     * - SELECT * FROM users WHERE username = 'joe'          // Uses primary key
+     * - SELECT * FROM users WHERE birth_year = 1981        // Uses secondary index
+     * - SELECT * FROM users                               // Full scan is explicit
+     * <p>
+     * This query requires ALLOW FILTERING:
+     * - SELECT * FROM users WHERE birth_year = 1981 AND country = 'FR' ALLOW FILTERING
+     * <p>
+     * When true, this field indicates the query is allowed to perform potentially expensive filtering operations
+     * that may scan large portions of the table to satisfy the query conditions.
+     */
+    public final boolean allowFiltering;
+
+    protected RowFilter(FilterElement root, boolean allowFiltering)
     {
         this.root = root;
+        this.allowFiltering = allowFiltering;
     }
 
     public FilterElement root()
@@ -294,7 +325,7 @@ public RowFilter without(Expression expression)
         if (root.size() == 1)
             return RowFilter.NONE;
 
-        return new RowFilter(root.filter(e -> !e.equals(expression)));
+        return new RowFilter(root.filter(e -> !e.equals(expression)), allowFiltering);
     }
 
     public RowFilter withoutExpressions()
@@ -307,12 +338,12 @@ public RowFilter withoutExpressions()
      */
     public RowFilter withoutDisjunctions()
     {
-        return new RowFilter(root.withoutDisjunctions());
+        return new RowFilter(root.withoutDisjunctions(), allowFiltering);
     }
 
     public RowFilter restrict(Predicate<Expression> filter)
     {
-        return new RowFilter(root.filter(filter));
+        return new RowFilter(root.filter(filter), allowFiltering);
     }
 
     public boolean isEmpty()
@@ -328,12 +359,12 @@ public String toString()
 
     public static Builder builder()
     {
-        return new Builder(null);
+        return new Builder(null, false);
     }
 
-    public static Builder builder(IndexRegistry indexRegistry)
+    public static Builder builder(IndexRegistry indexRegistry, boolean allowFiltering)
     {
-        return new Builder(indexRegistry);
+        return new Builder(indexRegistry, allowFiltering);
     }
 
     public static class Builder
@@ -341,15 +372,17 @@ public static class Builder
         private FilterElement.Builder current = new FilterElement.Builder(false);
 
         private final IndexRegistry indexRegistry;
+        private final Boolean allowFiltering;
 
-        public Builder(IndexRegistry indexRegistry)
+        public Builder(IndexRegistry indexRegistry, boolean allowFiltering)
         {
             this.indexRegistry = indexRegistry;
+            this.allowFiltering = allowFiltering;
         }
 
         public RowFilter build()
         {
-            return new RowFilter(current.build());
+            return new RowFilter(current.build(), allowFiltering);
         }
 
         public RowFilter buildFromRestrictions(StatementRestrictions restrictions,
@@ -363,7 +396,7 @@ public RowFilter buildFromRestrictions(StatementRestrictions restrictions,
             if (Guardrails.queryFilters.enabled(queryState))
                 Guardrails.queryFilters.guard(root.numFilteredValues(), "Select query", false, queryState);
 
-            return new RowFilter(root);
+            return new RowFilter(root, allowFiltering);
         }
 
         private FilterElement doBuild(StatementRestrictions restrictions,
@@ -420,7 +453,7 @@ public void addAllAsConjunction(Consumer<Builder> addToRowFilterDelegate)
             {
                 // If we're in disjunction mode, we must not pass the current builder to addToRowFilter.
                 // We create a new conjunction sub-builder instead and add all expressions there.
-                var builder = new Builder(indexRegistry);
+                var builder = new Builder(indexRegistry, allowFiltering);
                 addToRowFilterDelegate.accept(builder);
 
                 if (builder.current.expressions.size() == 1 && builder.current.children.isEmpty())
@@ -1840,20 +1873,37 @@ public static class Serializer
         public void serialize(RowFilter filter, DataOutputPlus out, int version) throws IOException
         {
             out.writeBoolean(false); // Old "is for thrift" boolean
+
             FilterElement.serializer.serialize(filter.root, out, version);
+
+            // CNDB-12425 - allowFiltering is only serialized in DS 11 and above
+            if (version >= MessagingService.VERSION_DS_11)
+                out.writeBoolean(filter.allowFiltering);
         }
 
         public RowFilter deserialize(DataInputPlus in, int version, TableMetadata metadata) throws IOException
         {
-            in.readBoolean(); // Unused
+            // Skip unused "isForThrift" boolean from legacy versions
+            in.readBoolean();
+
             FilterElement operation = FilterElement.serializer.deserialize(in, version, metadata);
-            return new RowFilter(operation);
+
+            // CNDB-12425 - allowFiltering was added in DS 11
+            boolean allowFiltering = version >= MessagingService.VERSION_DS_11 && in.readBoolean();
+
+            return new RowFilter(operation, allowFiltering);
         }
 
         public long serializedSize(RowFilter filter, int version)
         {
-            return 1 // unused boolean
-                   + FilterElement.serializer.serializedSize(filter.root, version);
+            long size = 1; // unused boolean
+            size += FilterElement.serializer.serializedSize(filter.root, version);
+
+            // CNDB-12425 - We allow filtering during index build in DS 11 and above
+            if (version >= MessagingService.VERSION_DS_11)
+                size += TypeSizes.BOOL_SIZE; // for allowFiltering
+
+            return size;
         }
     }
 }
diff --git a/src/java/org/apache/cassandra/index/Index.java b/src/java/org/apache/cassandra/index/Index.java
index beb8280e674a..628abbfd7610 100644
--- a/src/java/org/apache/cassandra/index/Index.java
+++ b/src/java/org/apache/cassandra/index/Index.java
@@ -807,6 +807,17 @@ Indexer indexerFor(Predicate<Index> indexSelector,
         @Nullable
         QueryPlan queryPlanFor(RowFilter rowFilter);
 
+        /**
+         * Returns a new {@link QueryPlan} for the specified {@link RowFilter} and set of {@link Index}, or {@code null}
+         * if none of the indexes in this group supports the expression in the row filter.
+         *
+         * @param rowFilter a row filter
+         * @param indexes a set of indexes
+         * @return a new query plan for the specified {@link RowFilter} and {@link Set<Index>}, {@code null} otherwise
+         */
+        @Nullable
+        QueryPlan queryPlanForIndices(RowFilter rowFilter, Set<Index> indexes);
+
         /**
          * Get flush observer to observe partition/cell events generated by flushing SSTable (memtable flush or compaction).
          *
@@ -1030,6 +1041,7 @@ default boolean isTopK()
     enum Status
     {
         UNKNOWN,
+        INITIAL_BUILD_STARTED,
         FULL_REBUILD_STARTED,
         BUILD_FAILED,
         BUILD_SUCCEEDED,
diff --git a/src/java/org/apache/cassandra/index/IndexRegistry.java b/src/java/org/apache/cassandra/index/IndexRegistry.java
index 990bb8afb83f..13af357e35a5 100644
--- a/src/java/org/apache/cassandra/index/IndexRegistry.java
+++ b/src/java/org/apache/cassandra/index/IndexRegistry.java
@@ -21,7 +21,6 @@
 package org.apache.cassandra.index;
 
 import java.util.Collection;
-import java.util.HashSet;
 import java.util.Collections;
 import java.util.Optional;
 import java.util.Set;
@@ -239,6 +238,13 @@ public Index.QueryPlan queryPlanFor(RowFilter rowFilter)
                 return null;
             }
 
+            @Nullable
+            @Override
+            public Index.QueryPlan queryPlanForIndices(RowFilter rowFilter, Set<Index> indexes)
+            {
+                return null;
+            }
+
             @Nullable
             @Override
             public SSTableFlushObserver getFlushObserver(Descriptor descriptor, LifecycleNewTracker tracker, TableMetadata tableMetadata, long keyCount)
diff --git a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
index d4c75ed2a4f1..7c18bc5dcddc 100644
--- a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
+++ b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java
@@ -63,6 +63,8 @@
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
+import org.apache.cassandra.locator.TokenMetadataProvider;
+import org.apache.cassandra.utils.NoSpamLogger;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -118,6 +120,7 @@
 import org.apache.cassandra.io.sstable.format.SSTableReader;
 import org.apache.cassandra.locator.Endpoints;
 import org.apache.cassandra.locator.InetAddressAndPort;
+import org.apache.cassandra.net.MessagingService;
 import org.apache.cassandra.notifications.INotification;
 import org.apache.cassandra.notifications.INotificationConsumer;
 import org.apache.cassandra.notifications.SSTableAddedNotification;
@@ -125,6 +128,7 @@
 import org.apache.cassandra.schema.ColumnMetadata;
 import org.apache.cassandra.schema.IndexMetadata;
 import org.apache.cassandra.schema.Indexes;
+import org.apache.cassandra.service.ClientWarn;
 import org.apache.cassandra.service.StorageService;
 import org.apache.cassandra.service.pager.SinglePartitionPager;
 import org.apache.cassandra.tracing.Tracing;
@@ -172,7 +176,7 @@
  * <br><br>
  * Finally, this class provides a clear and safe lifecycle to manage index builds, either full rebuilds via
  * {@link this#rebuildIndexesBlocking(Set)} or builds of new sstables
- * added via {@link org.apache.cassandra.notifications.SSTableAddedNotification}s, guaranteeing
+ * added via {@link SSTableAddedNotification}s, guaranteeing
  * the following:
  * <ul>
  * <li>The initialization task and any subsequent successful (re)build mark the index as built.</li>
@@ -185,6 +189,8 @@
 public class SecondaryIndexManager implements IndexRegistry, INotificationConsumer
 {
     private static final Logger logger = LoggerFactory.getLogger(SecondaryIndexManager.class);
+    public static final String FELL_BACK_TO_ALLOW_FILTERING = "The query won't use the indexes [%s] on endpoints [%s] while the " +
+                                                              "indexes are still building on those nodes.";
 
     // default page size (in rows) when rebuilding the index for a whole partition
     public static final int DEFAULT_PAGE_SIZE = 10000;
@@ -284,7 +290,7 @@ private synchronized Future<?> createIndex(IndexMetadata indexDef, boolean isNew
         if (writableIndexes.put(index.getIndexMetadata().name, index) == null)
             logger.info("Index [{}] registered and writable.", index.getIndexMetadata().name);
 
-        markIndexesBuilding(ImmutableSet.of(index), true, isNewCF);
+        markIndexesBuilding(ImmutableSet.of(index), true, isNewCF, true);
 
         return buildIndex(index);
     }
@@ -356,19 +362,77 @@ public synchronized Future<?> addIndex(IndexMetadata indexDef, boolean isNewCF)
     }
 
     /**
-     * Throws an {@link IndexNotAvailableException} if any of the indexes in the specified {@link Index.QueryPlan} is
-     * not queryable, as it's defined by {@link #isIndexQueryable(Index)}.
-     *
-     * @param queryPlan a query plan
-     * @throws IndexNotAvailableException if the query plan has any index that is not queryable
+     * Validates if all indexes in the specified {@link Index.QueryPlan} are available for querying.
+     * 
+     * @param queryPlan the query plan containing indexes to validate
+     * @param allowFiltering if true, allows querying with indexes that are in initial build state
+     * @return true if the query plan can be executed, false if falling back to ALLOW FILTERING
+     * @throws IndexNotAvailableException if any index is not queryable and ALLOW FILTERING is not enabled
      */
-    public void checkQueryability(Index.QueryPlan queryPlan)
+    public boolean searcherFor(Index.QueryPlan queryPlan, boolean allowFiltering)
     {
+        InetAddressAndPort endpoint = FBUtilities.getBroadcastAddressAndPort();
+        // KATE: We can (maybe?) use the commented lines here and line 389 if we do not want to allow filtering with executeInternal on a bootstrapping node
+        //Set<InetAddressAndPort> bootstrappingNodes = new HashSet<>(TokenMetadataProvider.instance.getTokenMetadata()
+        //                                                                                         .getBootstrapTokens()
+        //                                                                                         .valueSet());
+
         for (Index index : queryPlan.getIndexes())
         {
+            String indexName = index.getIndexMetadata().name;
+            Index.Status indexStatus = getIndexStatus(endpoint, keyspace.getName(), indexName);
+            boolean isInitialBuilding = (indexStatus == Index.Status.INITIAL_BUILD_STARTED);
+            // CNDB-12425: support for ALLOW FILTERING during initial index build
             if (!isIndexQueryable(index))
+            {
+                if (allNodesOnDS11() && isInitialBuilding && allowFiltering)
+                //if (allNodesOnDS11() && isInitialBuilding && allowFiltering && !bootstrappingNodes.contains(endpoint))
+                {
+                    warnAboutAllowFilteringFallback(Collections.singleton(indexName), Collections.singleton(endpoint));
+                    return false;
+                }
+
+                // We will reject the query here if the index is building and ALLOW FILTERING is not allowed
                 throw new IndexNotAvailableException(index);
+            }
         }
+
+        return true;
+    }
+
+    /**
+     * Logs a warning about falling back to ALLOW FILTERING in the case of:
+     *      - indexes being under initial build.
+     *      - ALLOW FILTERING specified in the query.
+     *      - the type of query allows the query to be executed with ALLOW FILTERING.
+     *
+     * @param indexesNames names of the indexes being built
+     * @param endpoints node endpoints where the indexes are being built
+     */
+    private static void warnAboutAllowFilteringFallback(Set<String> indexesNames, Set<InetAddressAndPort> endpoints)
+    {
+        NoSpamLogger.log(logger, NoSpamLogger.Level.WARN, 1, TimeUnit.MINUTES,
+                         SecondaryIndexManager.FELL_BACK_TO_ALLOW_FILTERING, indexesNames, endpoints);
+        ClientWarn.instance.warn(String.format(SecondaryIndexManager.FELL_BACK_TO_ALLOW_FILTERING, indexesNames, endpoints),
+                                 indexesNames);
+    }
+
+    /**
+     * Checks if all nodes in the keyspace are on VERSION_DS_11 messaging version.
+     *
+     * @return true if all nodes are on VERSION_DS_11, false if any node (including this one) is on a lower version
+     */
+    private boolean allNodesOnDS11()
+    {
+        InetAddressAndPort endpoint = FBUtilities.getBroadcastAddressAndPort();
+        Set<InetAddressAndPort> badNodes = MessagingService.instance()
+                                                           .endpointsWithConnectionsOnVersionBelow(keyspace.getName(),
+                                                                                                   MessagingService.VERSION_DS_11);
+
+        if (MessagingService.current_version < MessagingService.VERSION_DS_11)
+            badNodes.add(endpoint);
+
+        return badNodes.isEmpty();
     }
 
     /**
@@ -576,7 +640,7 @@ public static String getIndexName(String cfName)
 
     /**
      * Performs a blocking (re)indexing/recovery of the specified SSTables for the specified indexes.
-     *
+     * <p>
      * If the index doesn't support ALL {@link Index.LoadType} it performs a recovery {@link Index#getRecoveryTaskSupport()}
      * instead of a build {@link Index#getBuildTaskSupport()}
      * 
@@ -604,7 +668,7 @@ private Future<?> buildIndexesAsync(Collection<SSTableReader> sstables, Set<Inde
 
         // Mark all indexes as building: this step must happen first, because if any index can't be marked, the whole
         // process needs to abort
-        markIndexesBuilding(indexes, isFullRebuild, false);
+        markIndexesBuilding(indexes, isFullRebuild, false, false);
 
         // Build indexes in a try/catch, so that any index not marked as either built or failed will be marked as failed:
         final Set<Index> builtIndexes = Sets.newConcurrentHashSet();
@@ -616,7 +680,7 @@ private Future<?> buildIndexesAsync(Collection<SSTableReader> sstables, Set<Inde
                     sstables.stream().map(SSTableReader::toString).collect(Collectors.joining(",")));
 
         // Group all building tasks
-        Map<Index.IndexBuildingSupport, Set<Index>> byType = new HashMap<>();
+        Map<IndexBuildingSupport, Set<Index>> byType = new HashMap<>();
         for (Index index : indexes)
         {
             IndexBuildingSupport buildOrRecoveryTask = isFullRebuild
@@ -743,6 +807,9 @@ private String getIndexNames(Set<Index> indexes)
      * the SecondaryIndexManager instance, it means all invocations for all different indexes will go through the same
      * lock, but this is fine as the work done while holding such lock is trivial.
      * <p>
+     * isCreateIndex is used to differentiate whether a full rebuild is invoked when user is creating a new index or
+     * full rebuild is started by failed scrub or nodetool rebuild command. It matters as we want to fall back to ALLOW FILTERING
+     * (for queries with ALLOW FILTERING) only in the case a user creates a new index.
      * {@link #markIndexBuilt(Index, boolean)} or {@link #markIndexFailed(Index, boolean)} should be always called after
      * the rebuilding has finished, so that the index build state can be correctly managed and the index rebuilt.
      *
@@ -750,9 +817,10 @@ private String getIndexNames(Set<Index> indexes)
      * @param isFullRebuild {@code true} if this method is invoked as a full index rebuild, {@code false} otherwise
      * @param isNewCF {@code true} if this method is invoked when initializing a new table/columnfamily (i.e. loading a CF at startup),
      * {@code false} for all other cases (i.e. newly added index)
+     * @param isCreateIndex {@code true} if this method is invoked when creating a new index, {@code false} otherwise
      */
     @VisibleForTesting
-    public synchronized void markIndexesBuilding(Set<Index> indexes, boolean isFullRebuild, boolean isNewCF)
+    public synchronized void markIndexesBuilding(Set<Index> indexes, boolean isFullRebuild, boolean isNewCF, boolean isCreateIndex)
     {
         String keyspaceName = baseCfs.keyspace.getName();
 
@@ -777,7 +845,10 @@ public synchronized void markIndexesBuilding(Set<Index> indexes, boolean isFullR
                             if (isFullRebuild)
                             {
                                 needsFullRebuild.remove(indexName);
-                                makeIndexNonQueryable(index, Index.Status.FULL_REBUILD_STARTED);
+                                if (!isCreateIndex)
+                                    makeIndexNonQueryable(index, Index.Status.FULL_REBUILD_STARTED);
+                                else if (!isNewCF)
+                                    makeIndexNonQueryable(index, Index.Status.INITIAL_BUILD_STARTED);
                             }
 
                             if (counter.getAndIncrement() == 0 && DatabaseDescriptor.isDaemonInitialized() && !isNewCF)
@@ -787,7 +858,7 @@ public synchronized void markIndexesBuilding(Set<Index> indexes, boolean isFullR
 
     /**
      * Marks the specified index as built if there are no in progress index builds and the index is not failed.
-     * {@link #markIndexesBuilding(Set, boolean, boolean)} should always be invoked before this method.
+     * {@link #markIndexesBuilding(Set, boolean, boolean, boolean)} should always be invoked before this method.
      *
      * @param index the index to be marked as built
      * @param isFullRebuild {@code true} if this method is invoked as a full index rebuild, {@code false} otherwise
@@ -813,7 +884,7 @@ public synchronized void markIndexBuilt(Index index, boolean isFullRebuild)
 
     /**
      * Marks the specified index as failed.
-     * {@link #markIndexesBuilding(Set, boolean, boolean)} should always be invoked before this method.
+     * {@link #markIndexesBuilding(Set, boolean, boolean, boolean)} should always be invoked before this method.
      *
      * @param index the index to be marked as built
      * @param isInitialBuild {@code true} if the index failed during its initial build, {@code false} otherwise
@@ -1168,7 +1239,7 @@ public void deletePartition(UnfilteredRowIterator partition, int nowInSec)
     /**
      * Called at query time to choose which (if any) of the registered index implementations to use for a given query.
      * <p>
-     * This is a two step processes, firstly compiling the set of searchable indexes then choosing the one which reduces
+     * This is a two-step processes, firstly compiling the set of searchable indexes then choosing the one which reduces
      * the search space the most.
      * <p>
      * In the first phase, if the command's RowFilter contains any custom index expressions, the indexes that they
@@ -1808,21 +1879,58 @@ public static void shutdownAndWait(long timeout, TimeUnit units) throws Interrup
      * @param indexQueryPlan index query plan used in the read command
      * @param level consistency level of read command
      */
-    public static <E extends Endpoints<E>> E filterForQuery(E liveEndpoints, Keyspace keyspace, Index.QueryPlan indexQueryPlan, ConsistencyLevel level)
+    public static <E extends Endpoints<E>> E filterForQuery(E liveEndpoints,
+                                                            Keyspace keyspace,
+                                                            Index.QueryPlan indexQueryPlan,
+                                                            ConsistencyLevel level,
+                                                            boolean allowFiltering)
     {
-        E queryableEndpoints = liveEndpoints.filter(replica -> {
+        int initial = liveEndpoints.size();
+        Set<InetAddressAndPort> badNodes = MessagingService.instance().
+                                                           endpointsWithConnectionsOnVersionBelow(keyspace.getName(),
+                                                                                                  MessagingService.VERSION_DS_11);
+        if (MessagingService.current_version < MessagingService.VERSION_DS_11)
+            badNodes.add(FBUtilities.getBroadcastAddressAndPort());
+
+        assert liveEndpoints.endpoints().containsAll(badNodes);
 
+        boolean considerAllowFiltering = badNodes.isEmpty();
+
+        Set<InetAddressAndPort> filteringEndpoints = new HashSet<>();
+        Set<String> indexesNames = new HashSet<>();
+
+        E queryableEndpoints = liveEndpoints.filter(replica -> {
             for (Index index : indexQueryPlan.getIndexes())
             {
                 Index.Status status = getIndexStatus(replica.endpoint(), keyspace.getName(), index.getIndexMetadata().name);
+                
                 if (!index.isQueryable(status))
-                    return false;
+                {
+                    // CNDB-12425: During initial index build, replicas determine whether to use the index or fall back to filtering.
+                    // This decision depends on:
+                    // 1. Index build status on the replica
+                    // 2. ALLOW FILTERING flag in the query
+                    // Note: Not all queries support ALLOW FILTERING even when specified
+                    // Implementation detail: indexQueryPlan is not serialized, only the allowFiltering flag is sent to replicas.
+                    if (considerAllowFiltering && status == Index.Status.INITIAL_BUILD_STARTED && allowFiltering)
+                    {
+                        filteringEndpoints.add(replica.endpoint());
+                        indexesNames.add(index.getIndexMetadata().name);
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
             }
 
             return true;
         });
 
-        int initial = liveEndpoints.size();
+        // Emit a single warning for all building indexes and their endpoints
+        if (!indexesNames.isEmpty())
+            warnAboutAllowFilteringFallback(indexesNames, filteringEndpoints);
+
         int filtered = queryableEndpoints.size();
 
         // Throw ReadFailureException if read request cannot satisfy Consistency Level due to non-queryable indexes.
@@ -1941,9 +2049,6 @@ public synchronized static void receivePeerIndexStatus(InetAddressAndPort endpoi
 
     private synchronized static void propagateLocalIndexStatus(String keyspace, String index, Index.Status status)
     {
-        if (!Gossiper.instance.isEnabled())
-            return;
-
         try
         {
             Map<String, Index.Status> states = peerIndexStatus.computeIfAbsent(FBUtilities.getBroadcastAddressAndPort(),
@@ -1955,6 +2060,11 @@ private synchronized static void propagateLocalIndexStatus(String keyspace, Stri
             else
                 states.put(keyspaceIndex, status);
 
+            // Make sure to check this after peerIndexStatus is populatedm but before the JSON is built: we don't need
+            // the latter if there's no Gossiper (as in CNDB), so we can avoid the related CPU and memory usage.
+            if (!Gossiper.instance.isEnabled())
+                return;
+
             String newStatus = JSONValue.toJSONString(states.entrySet().stream()
                                                             .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().toString())));
             statusPropagationExecutor.submit(() -> {
diff --git a/src/java/org/apache/cassandra/index/SingletonIndexGroup.java b/src/java/org/apache/cassandra/index/SingletonIndexGroup.java
index c6d5d735f1d8..f2aaac5a0f21 100644
--- a/src/java/org/apache/cassandra/index/SingletonIndexGroup.java
+++ b/src/java/org/apache/cassandra/index/SingletonIndexGroup.java
@@ -72,7 +72,7 @@ public void addIndex(Index index)
         // This class does not work for SAI because the `componentsForNewBuid` method would be incorrect (so more
         // generally, it does not work for indexes that use dedicated sstable components, which is only SAI). See
         // comments on `componentsForNewBuid` for more details.
-        Preconditions.checkState(!(index instanceof StorageAttachedIndex), "This shoudl not be used with SAI");
+        Preconditions.checkState(!(index instanceof StorageAttachedIndex), "This should not be used with SAI");
         delegate = index;
         indexes.add(index);
     }
@@ -120,6 +120,12 @@ public Index.QueryPlan queryPlanFor(RowFilter rowFilter)
         return null;
     }
 
+    @Override
+    public Index.QueryPlan queryPlanForIndices(RowFilter rowFilter, Set<Index> indexes)
+    {
+        throw new UnsupportedOperationException("This method should not be called on a SingletonIndexGroup");
+    }
+
     @Override
     public SSTableFlushObserver getFlushObserver(Descriptor descriptor, LifecycleNewTracker tracker, TableMetadata tableMetadata, long keyCount)
     {
diff --git a/src/java/org/apache/cassandra/index/sai/StorageAttachedIndex.java b/src/java/org/apache/cassandra/index/sai/StorageAttachedIndex.java
index 86f63042ce1f..56a7fdcffd5d 100644
--- a/src/java/org/apache/cassandra/index/sai/StorageAttachedIndex.java
+++ b/src/java/org/apache/cassandra/index/sai/StorageAttachedIndex.java
@@ -29,7 +29,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.NavigableMap;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.SortedMap;
@@ -78,7 +77,6 @@
 import org.apache.cassandra.dht.OrderPreservingPartitioner;
 import org.apache.cassandra.dht.RandomPartitioner;
 import org.apache.cassandra.exceptions.InvalidRequestException;
-import org.apache.cassandra.db.filter.ANNOptions;
 import org.apache.cassandra.index.Index;
 import org.apache.cassandra.index.IndexBuildDecider;
 import org.apache.cassandra.index.IndexRegistry;
diff --git a/src/java/org/apache/cassandra/index/sai/StorageAttachedIndexGroup.java b/src/java/org/apache/cassandra/index/sai/StorageAttachedIndexGroup.java
index d6cf0af7a78f..35c3bae2cb3a 100644
--- a/src/java/org/apache/cassandra/index/sai/StorageAttachedIndexGroup.java
+++ b/src/java/org/apache/cassandra/index/sai/StorageAttachedIndexGroup.java
@@ -240,6 +240,20 @@ public StorageAttachedIndexQueryPlan queryPlanFor(RowFilter rowFilter)
         return StorageAttachedIndexQueryPlan.create(baseCfs, queryMetrics, indices, rowFilter);
     }
 
+    @Override
+    public StorageAttachedIndexQueryPlan queryPlanForIndices(RowFilter rowFilter, Set<Index> indexes)
+    {
+        Set<StorageAttachedIndex> saiIndexes = new HashSet<>();
+        for (Index index : indexes)
+        {
+            assert index instanceof StorageAttachedIndex : "Index is not a StorageAttachedIndex";
+            assert indices.contains(index) : "Index does not belong to this group";
+            saiIndexes.add((StorageAttachedIndex) index);
+        }
+
+        return StorageAttachedIndexQueryPlan.create(baseCfs, queryMetrics, saiIndexes, rowFilter);
+    }
+
     @Override
     public SSTableFlushObserver getFlushObserver(Descriptor descriptor, LifecycleNewTracker tracker, TableMetadata tableMetadata, long keyCount)
     {
diff --git a/src/java/org/apache/cassandra/index/sasi/SASIIndexBuilder.java b/src/java/org/apache/cassandra/index/sasi/SASIIndexBuilder.java
index 22916bd0332d..32a422961146 100644
--- a/src/java/org/apache/cassandra/index/sasi/SASIIndexBuilder.java
+++ b/src/java/org/apache/cassandra/index/sasi/SASIIndexBuilder.java
@@ -48,7 +48,7 @@
 import org.apache.cassandra.utils.ByteBufferUtil;
 import org.apache.cassandra.utils.UUIDGen;
 
-class SASIIndexBuilder extends SecondaryIndexBuilder
+public class SASIIndexBuilder extends SecondaryIndexBuilder
 {
     private final ColumnFamilyStore cfs;
     private final UUID compactionId = UUIDGen.getTimeUUID();
diff --git a/src/java/org/apache/cassandra/locator/ReplicaPlans.java b/src/java/org/apache/cassandra/locator/ReplicaPlans.java
index 2c4186a89bd6..a9486f69bac8 100644
--- a/src/java/org/apache/cassandra/locator/ReplicaPlans.java
+++ b/src/java/org/apache/cassandra/locator/ReplicaPlans.java
@@ -659,11 +659,17 @@ public static ReplicaPlan.ForPaxosWrite forPaxos(Keyspace keyspace, DecoratedKey
     }
 
 
-    private static <E extends Endpoints<E>> E candidatesForRead(Keyspace keyspace, Index.QueryPlan indexQueryPlan, ConsistencyLevel consistencyLevel, E liveNaturalReplicas)
+    private static <E extends Endpoints<E>> E candidatesForRead(Keyspace keyspace,
+                                                                Index.QueryPlan indexQueryPlan,
+                                                                ConsistencyLevel consistencyLevel,
+                                                                E liveNaturalReplicas,
+                                                                boolean allowFiltering)
     {
         E replicas = consistencyLevel.isDatacenterLocal() ? liveNaturalReplicas.filter(InOurDcTester.replicas()) : liveNaturalReplicas;
 
-        return indexQueryPlan != null ? SecondaryIndexManager.filterForQuery(replicas, keyspace, indexQueryPlan, consistencyLevel) : replicas;
+        return indexQueryPlan != null
+               ? SecondaryIndexManager.filterForQuery(replicas, keyspace, indexQueryPlan, consistencyLevel, allowFiltering)
+               : replicas;
     }
 
     private static <E extends Endpoints<E>> E contactForEachQuorumRead(NetworkTopologyStrategy replicationStrategy, E candidates)
@@ -723,11 +729,20 @@ public static ReplicaPlan.ForRangeRead forSingleReplicaRead(Keyspace keyspace, A
      * The candidate collection can be used for speculation, although at present
      * it would break EACH_QUORUM to do so without further filtering
      */
-    public static ReplicaPlan.ForTokenRead forRead(Keyspace keyspace, Token token, Index.QueryPlan indexQueryPlan, ConsistencyLevel consistencyLevel, SpeculativeRetryPolicy retry)
+    public static ReplicaPlan.ForTokenRead forRead(Keyspace keyspace,
+                                                   Token token,
+                                                   Index.QueryPlan indexQueryPlan,
+                                                   ConsistencyLevel consistencyLevel,
+                                                   SpeculativeRetryPolicy retry,
+                                                   boolean allowFiltering)
     {
         AbstractReplicationStrategy replicationStrategy = keyspace.getReplicationStrategy();
         IEndpointSnitch endpointSnitch = DatabaseDescriptor.getEndpointSnitch();
-        EndpointsForToken candidates = candidatesForRead(keyspace, indexQueryPlan, consistencyLevel, ReplicaLayout.forTokenReadLiveSorted(replicationStrategy, token).natural())
+        EndpointsForToken candidates = candidatesForRead(keyspace,
+                                                         indexQueryPlan,
+                                                         consistencyLevel,
+                                                         ReplicaLayout.forTokenReadLiveSorted(replicationStrategy, token).natural(),
+                                                         allowFiltering)
                                        .filter(endpointSnitch.filterByAffinity(keyspace.getName()));
         EndpointsForToken contacts = contactForRead(replicationStrategy, consistencyLevel, retry.equals(AlwaysSpeculativeRetryPolicy.INSTANCE), candidates)
                                      .filter(endpointSnitch.filterByAffinity(keyspace.getName()));
@@ -743,11 +758,20 @@ public static ReplicaPlan.ForTokenRead forRead(Keyspace keyspace, Token token, I
      *
      * There is no speculation for range read queries at present, so we never 'always speculate' here, and a failed response fails the query.
      */
-    public static ReplicaPlan.ForRangeRead forRangeRead(Keyspace keyspace, Index.QueryPlan indexQueryPlan, ConsistencyLevel consistencyLevel, AbstractBounds<PartitionPosition> range, int vnodeCount)
+    public static ReplicaPlan.ForRangeRead forRangeRead(Keyspace keyspace,
+                                                        Index.QueryPlan indexQueryPlan,
+                                                        ConsistencyLevel consistencyLevel,
+                                                        AbstractBounds<PartitionPosition> range,
+                                                        int vnodeCount,
+                                                        boolean allowFiltering)
     {
         AbstractReplicationStrategy replicationStrategy = keyspace.getReplicationStrategy();
         IEndpointSnitch endpointSnitch = DatabaseDescriptor.getEndpointSnitch();
-        EndpointsForRange candidates = candidatesForRead(keyspace, indexQueryPlan, consistencyLevel, ReplicaLayout.forRangeReadLiveSorted(replicationStrategy, range).natural())
+        EndpointsForRange candidates = candidatesForRead(keyspace,
+                                                         indexQueryPlan,
+                                                         consistencyLevel,
+                                                         ReplicaLayout.forRangeReadLiveSorted(replicationStrategy, range).natural(),
+                                                         allowFiltering)
                                        .filter(endpointSnitch.filterByAffinity(keyspace.getName()));
         EndpointsForRange contacts = contactForRead(replicationStrategy, consistencyLevel, false, candidates)
                                      .filter(endpointSnitch.filterByAffinity(keyspace.getName()));
diff --git a/src/java/org/apache/cassandra/service/reads/AbstractReadExecutor.java b/src/java/org/apache/cassandra/service/reads/AbstractReadExecutor.java
index cb0018975e9e..acf0ddc9c83a 100644
--- a/src/java/org/apache/cassandra/service/reads/AbstractReadExecutor.java
+++ b/src/java/org/apache/cassandra/service/reads/AbstractReadExecutor.java
@@ -204,7 +204,7 @@ public static AbstractReadExecutor getReadExecutor(SinglePartitionReadCommand co
         ColumnFamilyStore cfs = keyspace.getColumnFamilyStore(command.metadata().id);
         SpeculativeRetryPolicy retry = cfs.metadata().params.speculativeRetry;
 
-        ReplicaPlan.ForTokenRead replicaPlan = ReplicaPlans.forRead(keyspace, command.partitionKey().getToken(), command.indexQueryPlan(), consistencyLevel, retry);
+        ReplicaPlan.ForTokenRead replicaPlan = ReplicaPlans.forRead(keyspace, command.partitionKey().getToken(), command.indexQueryPlan(), consistencyLevel, retry, command.rowFilter().allowFiltering);
 
         if (replicaPlan.candidates().stream().noneMatch(replica -> replica.endpoint().equals(FBUtilities.getBroadcastAddressAndPort())))
         {
diff --git a/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java b/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java
index 63291c34a943..c592bbc6a435 100644
--- a/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java
+++ b/src/java/org/apache/cassandra/service/reads/range/RangeCommands.java
@@ -76,7 +76,8 @@ static RangeCommandIterator rangeCommandIterator(PartitionRangeReadCommand comma
         ReplicaPlanIterator replicaPlans = new ReplicaPlanIterator(command.dataRange().keyRange(),
                                                                    command.indexQueryPlan(),
                                                                    keyspace,
-                                                                   consistencyLevel);
+                                                                   consistencyLevel,
+                                                                   command.rowFilter().allowFiltering);
         if (command.isTopK())
             return new ScanAllRangesCommandIterator(keyspace, replicaPlans, command, replicaPlans.size(), queryStartNanoTime, readTracker);
 
diff --git a/src/java/org/apache/cassandra/service/reads/range/ReplicaPlanIterator.java b/src/java/org/apache/cassandra/service/reads/range/ReplicaPlanIterator.java
index 605afa4db632..7d592882e0be 100644
--- a/src/java/org/apache/cassandra/service/reads/range/ReplicaPlanIterator.java
+++ b/src/java/org/apache/cassandra/service/reads/range/ReplicaPlanIterator.java
@@ -36,7 +36,6 @@
 import org.apache.cassandra.locator.ReplicaPlan;
 import org.apache.cassandra.locator.ReplicaPlans;
 import org.apache.cassandra.locator.TokenMetadata;
-import org.apache.cassandra.service.StorageService;
 import org.apache.cassandra.utils.AbstractIterator;
 import org.apache.cassandra.utils.Pair;
 
@@ -45,6 +44,7 @@ class ReplicaPlanIterator extends AbstractIterator<ReplicaPlan.ForRangeRead>
     private final Keyspace keyspace;
     private final ConsistencyLevel consistency;
     private final Index.QueryPlan indexQueryPlan;
+    private final boolean allowFiltering;
     @VisibleForTesting
     final Iterator<? extends AbstractBounds<PartitionPosition>> ranges;
     private final int rangeCount;
@@ -52,11 +52,13 @@ class ReplicaPlanIterator extends AbstractIterator<ReplicaPlan.ForRangeRead>
     ReplicaPlanIterator(AbstractBounds<PartitionPosition> keyRange,
                         Index.QueryPlan indexQueryPlan,
                         Keyspace keyspace,
-                        ConsistencyLevel consistency)
+                        ConsistencyLevel consistency,
+                        boolean allowFiltering)
     {
         this.indexQueryPlan = indexQueryPlan;
         this.keyspace = keyspace;
         this.consistency = consistency;
+        this.allowFiltering = allowFiltering;
 
 
         List<? extends AbstractBounds<PartitionPosition>> l = keyspace.getReplicationStrategy() instanceof LocalStrategy
@@ -80,7 +82,7 @@ protected ReplicaPlan.ForRangeRead computeNext()
         if (!ranges.hasNext())
             return endOfData();
 
-        return ReplicaPlans.forRangeRead(keyspace, indexQueryPlan, consistency, ranges.next(), 1);
+        return ReplicaPlans.forRangeRead(keyspace, indexQueryPlan, consistency, ranges.next(), 1, allowFiltering);
     }
 
     /**
@@ -102,7 +104,7 @@ private static List<AbstractBounds<PartitionPosition>> getRestrictedRanges(Token
         while (ringIter.hasNext())
         {
             /*
-             * remainder is a range/bounds of partition positions and we want to split it with a token. We want to split
+             * remainder is a range/bounds of partition positions, and we want to split it with a token. We want to split
              * using the key returned by token.maxKeyBound. For instance, if remainder is [DK(10, 'foo'), DK(20, 'bar')],
              * and we have 3 nodes with tokens 0, 15, 30, we want to split remainder to A=[DK(10, 'foo'), 15] and
              * B=(15, DK(20, 'bar')]. But since we can't mix tokens and keys at the same time in a range, we use
diff --git a/test/distributed/org/apache/cassandra/distributed/test/ByteBuddyUtils.java b/test/distributed/org/apache/cassandra/distributed/test/ByteBuddyUtils.java
new file mode 100644
index 000000000000..25f36b92f9dd
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/ByteBuddyUtils.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.implementation.bind.annotation.RuntimeType;
+import net.bytebuddy.implementation.bind.annotation.SuperCall;
+import org.apache.cassandra.index.sai.StorageAttachedIndex;
+import org.apache.cassandra.net.MessagingService;
+
+import java.util.concurrent.Future;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ThreadLocalRandom;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+public class ByteBuddyUtils
+{
+    /**
+     * Injection to set the current version of a node to DS 10.
+     */
+    public static class BB
+    {
+        public static void install(ClassLoader classLoader, int node)
+        {
+            // inject randomly first or second node to make sure it works if the node is a coordinator or replica
+            if (node == ThreadLocalRandom.current().nextInt(1, 3))
+            {
+                new ByteBuddy().rebase(MessagingService.class)
+                               .method(named("currentVersion"))
+                               .intercept(MethodDelegation.to(BB.class))
+                               .make()
+                               .load(classLoader, ClassLoadingStrategy.Default.INJECTION);
+            }
+        }
+
+        @SuppressWarnings("unused")
+        public static int currentVersion()
+        {
+            return MessagingService.VERSION_DS_10;
+        }
+    }
+
+    /**
+     * Injection to block SAI index building for 30 seconds.
+     */
+    public static class IndexBuildBlocker
+    {
+        public static void blockIndexBuilding(ClassLoader cl, int nodeNumber)
+        {
+            new ByteBuddy().rebase(StorageAttachedIndex.class)
+                           .method(named("startInitialBuild"))
+                           .intercept(MethodDelegation.to(IndexBuildInterceptor.class))
+                           .make()
+                           .load(cl, ClassLoadingStrategy.Default.INJECTION);
+        }
+    }
+
+    public static class IndexBuildInterceptor
+    {
+        @RuntimeType
+        public static Future<?> intercept(@SuperCall Callable<Future<?>> zuper) throws Exception
+        {
+            Thread.sleep(30000); // 30 seconds delay
+            return zuper.call();
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/distributed/org/apache/cassandra/distributed/test/index/IndexTestBase.java b/test/distributed/org/apache/cassandra/distributed/test/index/IndexTestBase.java
new file mode 100644
index 000000000000..5743b054498d
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/index/IndexTestBase.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.index;
+
+import org.apache.cassandra.db.Keyspace;
+import org.apache.cassandra.distributed.test.TestBaseImpl;
+import org.apache.cassandra.distributed.api.IInvokableInstance;
+import org.apache.cassandra.index.Index;
+import org.apache.cassandra.index.SecondaryIndexManager;
+import org.apache.cassandra.locator.InetAddressAndPort;
+import org.apache.cassandra.schema.KeyspaceMetadata;
+import org.apache.cassandra.schema.Schema;
+import org.apache.cassandra.schema.TableMetadata;
+import org.apache.cassandra.utils.FBUtilities;
+
+import java.net.InetAddress;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+import static org.awaitility.Awaitility.await;
+
+/**
+ * Base class for distributed index tests providing common functionality for index status management
+ * and verification. Can be used by any secondary index implementation (SAI, SASI, etc.).
+ */
+public class IndexTestBase extends TestBaseImpl
+{
+    protected static void markIndexBuilding(IInvokableInstance node,
+                                            String keyspace,
+                                            String table,
+                                            String indexName,
+                                            boolean isInitialBuild,
+                                            boolean isNewCF)
+    {
+        node.runOnInstance(() -> {
+            SecondaryIndexManager sim = Objects.requireNonNull(Schema.instance.getKeyspaceInstance(keyspace))
+                                               .getColumnFamilyStore(table).indexManager;
+            Index index = sim.getIndexByName(indexName);
+            sim.markIndexesBuilding(Collections.singleton(index), true, isNewCF, isInitialBuild);
+        });
+    }
+
+    public static void waitForIndexingStatus(IInvokableInstance node, String keyspace, String index, IInvokableInstance replica, Index.Status status)
+    {
+        InetAddressAndPort replicaAddressAndPort = getFullAddress(replica);
+        await().atMost(5, TimeUnit.SECONDS)
+               .until(() -> node.callOnInstance(() -> getIndexStatus(keyspace, index, replicaAddressAndPort) == status));
+    }
+
+    protected static InetAddressAndPort getFullAddress(IInvokableInstance node)
+    {
+        InetAddress address = node.broadcastAddress().getAddress();
+        int port = node.callOnInstance(() -> FBUtilities.getBroadcastAddressAndPort().port);
+        return InetAddressAndPort.getByAddressOverrideDefaults(address, port);
+    }
+
+    protected static Index.Status getIndexStatus(String keyspaceName, String indexName, InetAddressAndPort replica)
+    {
+        KeyspaceMetadata keyspace = Schema.instance.getKeyspaceMetadata(keyspaceName);
+        if (keyspace == null)
+            return Index.Status.UNKNOWN;
+
+        TableMetadata table = keyspace.findIndexedTable(indexName).orElse(null);
+        if (table == null)
+            return Index.Status.UNKNOWN;
+
+        SecondaryIndexManager indexManager = Keyspace.openAndGetStore(table).indexManager;
+
+        return indexManager.getIndexStatus(replica, keyspaceName, indexName);
+    }
+}
diff --git a/test/distributed/org/apache/cassandra/distributed/test/ring/BootstrapTest.java b/test/distributed/org/apache/cassandra/distributed/test/ring/BootstrapTest.java
index 747caf0a1f4a..6c1bad088e16 100644
--- a/test/distributed/org/apache/cassandra/distributed/test/ring/BootstrapTest.java
+++ b/test/distributed/org/apache/cassandra/distributed/test/ring/BootstrapTest.java
@@ -23,6 +23,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+import org.apache.cassandra.distributed.test.TestBaseImpl;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -36,7 +37,6 @@
 import org.apache.cassandra.distributed.api.IInvokableInstance;
 import org.apache.cassandra.distributed.api.TokenSupplier;
 import org.apache.cassandra.distributed.shared.NetworkTopology;
-import org.apache.cassandra.distributed.test.TestBaseImpl;
 
 import static java.util.Arrays.asList;
 import static org.apache.cassandra.distributed.action.GossipHelper.bootstrap;
@@ -76,7 +76,7 @@ public void bootstrapTest() throws Throwable
         int expandedNodeCount = originalNodeCount + 1;
 
         try (Cluster cluster = builder().withNodes(originalNodeCount)
-                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount))
+                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount, 1))
                                         .withNodeIdTopology(NetworkTopology.singleDcNetworkTopology(expandedNodeCount, "dc0", "rack0"))
                                         .withConfig(config -> config.with(NETWORK, GOSSIP))
                                         .start())
@@ -102,13 +102,13 @@ public void bootstrapTest() throws Throwable
     }
 
     @Test
-    public void readWriteDuringBootstrapTest() throws Throwable
+    public void  readWriteDuringBootstrapTest() throws Throwable
     {
         int originalNodeCount = 2;
         int expandedNodeCount = originalNodeCount + 1;
 
         try (Cluster cluster = builder().withNodes(originalNodeCount)
-                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount))
+                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount, 1))
                                         .withNodeIdTopology(NetworkTopology.singleDcNetworkTopology(expandedNodeCount, "dc0", "rack0"))
                                         .withConfig(config -> config.with(NETWORK, GOSSIP))
                                         .start())
@@ -150,5 +150,4 @@ public static Map<Integer, Long> count(ICluster cluster)
                         .collect(Collectors.toMap(nodeId -> nodeId,
                                                   nodeId -> (Long) cluster.get(nodeId).executeInternal("SELECT count(*) FROM " + KEYSPACE + ".tbl")[0][0]));
     }
-
 }
diff --git a/test/distributed/org/apache/cassandra/distributed/test/ring/IndexBuildDuringBootstrapTest.java b/test/distributed/org/apache/cassandra/distributed/test/ring/IndexBuildDuringBootstrapTest.java
new file mode 100644
index 000000000000..fef54a32ed04
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/ring/IndexBuildDuringBootstrapTest.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.ring;
+
+import org.apache.cassandra.config.CassandraRelevantProperties;
+import org.apache.cassandra.distributed.test.ByteBuddyUtils;
+import org.apache.cassandra.distributed.test.index.IndexTestBase;
+import org.apache.cassandra.distributed.Cluster;
+import org.apache.cassandra.distributed.api.ConsistencyLevel;
+import org.apache.cassandra.distributed.api.IInstanceConfig;
+import org.apache.cassandra.distributed.api.IInvokableInstance;
+import org.apache.cassandra.distributed.api.TokenSupplier;
+import org.apache.cassandra.distributed.shared.NetworkTopology;
+import org.assertj.core.api.Assertions;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.lang.management.ManagementFactory;
+import java.util.Map;
+
+import static java.util.Arrays.asList;
+import static org.apache.cassandra.distributed.action.GossipHelper.*;
+import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
+import static org.apache.cassandra.distributed.api.Feature.NETWORK;
+import static org.apache.cassandra.distributed.test.ring.BootstrapTest.count;
+import static org.apache.cassandra.distributed.test.ring.BootstrapTest.populate;
+import static org.apache.cassandra.distributed.test.sai.SAIUtil.waitForIndexQueryable;
+
+public class IndexBuildDuringBootstrapTest extends IndexTestBase
+{
+    private static final String INDEX_NOT_AVAILABLE_MESSAGE = "^Operation failed - received 0 responses" +
+                                                              " and 2 failures: INDEX_NOT_AVAILABLE from .+" +
+                                                              " INDEX_NOT_AVAILABLE from .+$";
+    private long savedMigrationDelay;
+
+    @Before
+    public void beforeTest()
+    {
+        // MigrationCoordinator schedules schema pull requests immediatelly when the node is just starting up, otherwise
+        // the first pull request is sent in 60 seconds. Whether we are starting up or not is detected by examining
+        // the node up-time and if it is lower than MIGRATION_DELAY, we consider the server is starting up.
+        // When we are running multiple test cases in the class, where each starts a node but in the same JVM, the
+        // up-time will be more or less relevant only for the first test. In order to enforce the startup-like behaviour
+        // for each test case, the MIGRATION_DELAY time is adjusted accordingly
+        savedMigrationDelay = CassandraRelevantProperties.MIGRATION_DELAY.getLong();
+        CassandraRelevantProperties.MIGRATION_DELAY.setLong(ManagementFactory.getRuntimeMXBean().getUptime() + savedMigrationDelay);
+    }
+
+    @After
+    public void afterTest()
+    {
+        CassandraRelevantProperties.MIGRATION_DELAY.setLong(savedMigrationDelay);
+    }
+
+    private static final String TABLE = "tbl";
+    private static final String INDEX_NAME = "idx_v1";
+    private static final String SCAN_QUERY = "SELECT * FROM " + KEYSPACE + '.' + TABLE;
+    private static final String INDEX_QUERY = "SELECT * FROM " + KEYSPACE + '.' + TABLE + " WHERE v = 50";
+    private static final String ALLOW_FILTERING_QUERY = "SELECT * FROM " + KEYSPACE + '.' + TABLE + " WHERE v = 50 ALLOW FILTERING";
+
+    // Test Case 1: We initiate index create before bootstrap and finish it during bootstrap.
+    @Test
+    public void indexBuildDuringBootstrapTestV1() throws Throwable
+    {
+        int originalNodeCount = 2;
+        int expandedNodeCount = originalNodeCount + 1;
+
+        try (Cluster cluster = builder().withNodes(originalNodeCount)
+                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount, 1))
+                                        .withNodeIdTopology(NetworkTopology.singleDcNetworkTopology(expandedNodeCount, "dc0", "rack0"))
+                                        .withInstanceInitializer(ByteBuddyUtils.IndexBuildBlocker::blockIndexBuilding)
+                                        .withConfig(config -> config.with(NETWORK, GOSSIP))
+                                        .start())
+        {
+            populate(cluster, 0, 100);
+
+            // Start index build before bootstrap
+            cluster.schemaChange("CREATE CUSTOM INDEX " + INDEX_NAME + " ON " + KEYSPACE + '.' + TABLE + "(v) USING 'StorageAttachedIndex'");
+
+            // Prepare the new node but don't start bootstrap yet
+            IInstanceConfig config = cluster.newInstanceConfig();
+            IInvokableInstance newInstance = cluster.bootstrap(config);
+
+            // Start bootstrap
+            withProperty("cassandra.join_ring", false,
+                    () -> newInstance.startup(cluster));
+            cluster.forEach(statusToBootstrap(newInstance));
+
+            // Verify queries work during bootstrap and index build; though no data has been streamed yet
+            Assert.assertEquals(0, newInstance.executeInternal(SCAN_QUERY).length);
+            Assertions.assertThatThrownBy(() -> newInstance.executeInternal(INDEX_QUERY))
+                      .hasMessageMatching("The secondary index 'idx_v1' is not yet available");
+            Assertions.assertThatThrownBy(() -> newInstance.executeInternal(ALLOW_FILTERING_QUERY))
+                      .hasMessageMatching("The secondary index 'idx_v1' is not yet available");
+
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.QUORUM))
+                      .hasMessageMatching(INDEX_NOT_AVAILABLE_MESSAGE);
+            cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.QUORUM);
+
+            waitForIndexQueryable(cluster, KEYSPACE);
+
+            // Verify queries after index build completion and before bootstrap completion
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assert.assertEquals(0, newInstance.executeInternal(SCAN_QUERY).length);
+            Assert.assertEquals(0, newInstance.executeInternal(INDEX_QUERY).length);
+            Assert.assertEquals(0, newInstance.executeInternal(ALLOW_FILTERING_QUERY).length);
+
+            // Complete bootstrap
+            cluster.run(asList(pullSchemaFrom(cluster.get(1)), bootstrap()), newInstance.config().num());
+
+            for (Map.Entry<Integer, Long> e : count(cluster).entrySet())
+                Assert.assertEquals("Node " + e.getKey() + " has incorrect row state", 100L, e.getValue().longValue());
+
+            // Verify final state
+            assertQueryResults(newInstance, INDEX_QUERY);
+            assertQueryResults(newInstance, ALLOW_FILTERING_QUERY);
+            // Below fails with "Cannot achieve consistency level ALL"
+            //cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            // Below 2 fail with Cannot achieve consistency level ALL
+            // cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            // cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+
+            cluster.coordinator(3).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+        }
+    }
+
+    // Test Case 2: We initiate index create during bootstrap and finish it during bootstrap
+    @Test
+    public void indexBuildDuringBootstrapTestV2() throws Exception
+    {
+        int originalNodeCount = 2;
+        int expandedNodeCount = originalNodeCount + 1;
+
+        try (Cluster cluster = builder().withNodes(originalNodeCount)
+                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount, 1))
+                                        .withNodeIdTopology(NetworkTopology.singleDcNetworkTopology(expandedNodeCount, "dc0", "rack0"))
+                                        .withInstanceInitializer(ByteBuddyUtils.IndexBuildBlocker::blockIndexBuilding)
+                                        .withConfig(config -> config.with(NETWORK, GOSSIP))
+                                        .start())
+        {
+            populate(cluster, 0, 100);
+
+            // Prepare the new node but don't start bootstrap yet
+            IInstanceConfig config = cluster.newInstanceConfig();
+            IInvokableInstance newInstance = cluster.bootstrap(config);
+
+            // Start bootstrap
+            withProperty("cassandra.join_ring", false, () -> newInstance.startup(cluster));
+            cluster.forEach(statusToBootstrap(newInstance));
+
+            // Start index build during bootstrap
+            cluster.schemaChange("CREATE CUSTOM INDEX " + INDEX_NAME + " ON " + KEYSPACE + '.' + TABLE + "(v) USING 'StorageAttachedIndex'");
+
+            // Verify queries work during bootstrap and index build; though no data has been streamed yet
+            Assert.assertEquals(0, newInstance.executeInternal(SCAN_QUERY).length);
+            Assertions.assertThatThrownBy(() -> newInstance.executeInternal(INDEX_QUERY))
+                      .hasMessageMatching("The secondary index 'idx_v1' is not yet available");
+            newInstance.executeInternal(ALLOW_FILTERING_QUERY);
+
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            cluster.coordinator(3).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(3).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(3).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            waitForIndexQueryable(cluster, KEYSPACE);
+
+            // Verify queries after index build completion and before bootstrap completion
+            Assert.assertEquals(0, newInstance.executeInternal(SCAN_QUERY).length);
+            Assert.assertEquals(0, newInstance.executeInternal(INDEX_QUERY).length);
+            Assert.assertEquals(0, newInstance.executeInternal(ALLOW_FILTERING_QUERY).length);
+
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.QUORUM);
+
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            cluster.coordinator(3).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(3).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(3).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            // Complete bootstrap
+            cluster.run(asList(pullSchemaFrom(cluster.get(1)), bootstrap()), newInstance.config().num());
+
+            for (Map.Entry<Integer, Long> e : count(cluster).entrySet())
+                Assert.assertEquals("Node " + e.getKey() + " has incorrect row state", 100L, e.getValue().longValue());
+
+            // Verify final state
+            assertQueryResults(newInstance, INDEX_QUERY);
+            assertQueryResults(newInstance, ALLOW_FILTERING_QUERY);
+            // Below fails with "Cannot achieve consistency level ALL"
+            //cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            // Below 2 fail with Cannot achieve consistency level ALL
+            // cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            // cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+
+            cluster.coordinator(3).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+        }
+    }
+
+    // Test Case 3: We initiate index create during bootstrap and finish it after bootstrap
+    @Test
+    public void indexBuildDuringBootstrapTestV3() throws Throwable
+    {
+        int originalNodeCount = 2;
+        int expandedNodeCount = originalNodeCount + 1;
+
+        try (Cluster cluster = builder().withNodes(originalNodeCount)
+                                        .withTokenSupplier(TokenSupplier.evenlyDistributedTokens(expandedNodeCount, 1))
+                                        .withNodeIdTopology(NetworkTopology.singleDcNetworkTopology(expandedNodeCount, "dc0", "rack0"))
+                                        .withInstanceInitializer(ByteBuddyUtils.IndexBuildBlocker::blockIndexBuilding)
+                                        .withConfig(config -> config.with(NETWORK, GOSSIP))
+                                        .start())
+        {
+            populate(cluster, 0, 100);
+
+            // Prepare the new node but don't start bootstrap yet
+            IInstanceConfig config = cluster.newInstanceConfig();
+            IInvokableInstance newInstance = cluster.bootstrap(config);
+
+            // Start bootstrap
+            withProperty("cassandra.join_ring", false, () -> newInstance.startup(cluster));
+            cluster.forEach(statusToBootstrap(newInstance));
+
+            // Start index build during bootstrap
+            cluster.schemaChange("CREATE CUSTOM INDEX " + INDEX_NAME + " ON " + KEYSPACE + '.' + TABLE + "(v) USING 'StorageAttachedIndex'");
+
+            // Verify queries work during bootstrap and index build; though no data has been streamed yet
+            Assert.assertEquals(0, newInstance.executeInternal(SCAN_QUERY).length);
+            Assertions.assertThatThrownBy(() -> newInstance.executeInternal(INDEX_QUERY))
+                      .hasMessageMatching("The secondary index 'idx_v1' is not yet available");
+            Assert.assertEquals(0, newInstance.executeInternal(ALLOW_FILTERING_QUERY).length);
+
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.QUORUM);
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+            Assertions.assertThatThrownBy(() -> cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL))
+                      .hasMessageMatching("Cannot achieve consistency level ALL");
+
+            // Complete bootstrap
+            cluster.run(asList(pullSchemaFrom(cluster.get(1)), bootstrap()), newInstance.config().num());
+
+            waitForIndexQueryable(cluster, KEYSPACE);
+
+            for (Map.Entry<Integer, Long> e : count(cluster).entrySet())
+                Assert.assertEquals("Node " + e.getKey() + " has incorrect row state", 100L, e.getValue().longValue());
+
+            // Verify final state
+            assertQueryResults(newInstance, INDEX_QUERY);
+            assertQueryResults(newInstance, ALLOW_FILTERING_QUERY);
+            // Below fails with "Cannot achieve consistency level ALL"
+            //cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(1).execute(SCAN_QUERY, ConsistencyLevel.QUORUM);
+            // Below 2 fail with Cannot achieve consistency level ALL
+            // cluster.coordinator(1).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            // cluster.coordinator(1).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+
+            cluster.coordinator(3).execute(SCAN_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(INDEX_QUERY, ConsistencyLevel.ALL);
+            cluster.coordinator(3).execute(ALLOW_FILTERING_QUERY, ConsistencyLevel.ALL);
+        }
+    }
+
+    private void assertQueryResults(IInvokableInstance instance, String query)
+    {
+        Object[][] results = instance.executeInternal(query);
+        Assert.assertEquals(1, results.length);
+    }
+}
\ No newline at end of file
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/ANNOptionsDistributedTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/ANNOptionsDistributedTest.java
index 63dfff54dd9a..59ee23e019cc 100644
--- a/test/distributed/org/apache/cassandra/distributed/test/sai/ANNOptionsDistributedTest.java
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/ANNOptionsDistributedTest.java
@@ -16,14 +16,11 @@
 
 package org.apache.cassandra.distributed.test.sai;
 
-import java.util.concurrent.ThreadLocalRandom;
-
+import org.apache.cassandra.distributed.test.ByteBuddyUtils;
 import org.junit.Test;
 
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
-import net.bytebuddy.implementation.MethodDelegation;
 import org.apache.cassandra.config.CassandraRelevantProperties;
+import org.apache.cassandra.db.filter.ANNOptions;
 import org.apache.cassandra.distributed.Cluster;
 import org.apache.cassandra.distributed.api.ConsistencyLevel;
 import org.apache.cassandra.distributed.api.ICoordinator;
@@ -31,7 +28,6 @@
 import org.apache.cassandra.net.MessagingService;
 import org.assertj.core.api.Assertions;
 
-import static net.bytebuddy.matcher.ElementMatchers.named;
 import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
 import static org.apache.cassandra.distributed.api.Feature.NATIVE_PROTOCOL;
 import static org.apache.cassandra.distributed.api.Feature.NETWORK;
@@ -73,7 +69,7 @@ public void testANNOptionsWithAllDS10() throws Throwable
                                            .withConfig(config -> config.with(GOSSIP).with(NETWORK))
                                            .start(), RF))
         {
-            testSelectWithAnnOptions(cluster, "ANN options are not supported in clusters below DS 11.");
+            testSelectWithAnnOptions(cluster, ANNOptions.REQUIRES_HIGHER_MESSAGING_VERSION);
         }
     }
 
@@ -86,11 +82,11 @@ public void testANNOptionsWithMixedDS10AndDS11() throws Throwable
         assert CassandraRelevantProperties.DS_CURRENT_MESSAGING_VERSION.getInt() >= MessagingService.VERSION_DS_11;
 
         try (Cluster cluster = init(Cluster.build(NUM_REPLICAS)
-                                           .withInstanceInitializer(BB::install)
+                                           .withInstanceInitializer(ByteBuddyUtils.BB::install)
                                            .withConfig(config -> config.with(GOSSIP).with(NETWORK).with(NATIVE_PROTOCOL))
                                            .start(), RF))
         {
-            testSelectWithAnnOptions(cluster, "ANN options are not supported in clusters below DS 11.");
+            testSelectWithAnnOptions(cluster, ANNOptions.REQUIRES_HIGHER_MESSAGING_VERSION);
         }
     }
 
@@ -112,29 +108,5 @@ private static void testSelectWithAnnOptions(Cluster cluster, String expectedErr
                           .hasMessageContaining(expectedErrorMessage);
         }
     }
-
-    /**
-     * Injection to set the current version of the first cluster node to DS 10.
-     */
-    public static class BB
-    {
-        public static void install(ClassLoader classLoader, int node)
-        {
-            // inject randomly first or second node to make sure it works if the node is a coordinator or replica
-            if (node == ThreadLocalRandom.current().nextInt(1, 3))
-            {
-                new ByteBuddy().rebase(MessagingService.class)
-                               .method(named("currentVersion"))
-                               .intercept(MethodDelegation.to(BB.class))
-                               .make()
-                               .load(classLoader, ClassLoadingStrategy.Default.INJECTION);
-            }
-        }
-
-        @SuppressWarnings("unused")
-        public static int currentVersion()
-        {
-            return MessagingService.VERSION_DS_10;
-        }
-    }
 }
+
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/IndexAvailabilityTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/IndexAvailabilityTest.java
index 5f5a4918b95f..250bbe34869d 100644
--- a/test/distributed/org/apache/cassandra/distributed/test/sai/IndexAvailabilityTest.java
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/IndexAvailabilityTest.java
@@ -18,50 +18,47 @@
 
 package org.apache.cassandra.distributed.test.sai;
 
-import java.net.InetAddress;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
 import com.google.common.base.Objects;
+import org.apache.cassandra.distributed.test.index.IndexTestBase;
 import org.junit.Test;
 
 import org.apache.cassandra.cql3.ColumnIdentifier;
+import org.apache.cassandra.cql3.restrictions.StatementRestrictions;
 import org.apache.cassandra.db.ColumnFamilyStore;
-import org.apache.cassandra.db.Keyspace;
 import org.apache.cassandra.distributed.Cluster;
 import org.apache.cassandra.distributed.api.ConsistencyLevel;
 import org.apache.cassandra.distributed.api.IInvokableInstance;
-import org.apache.cassandra.distributed.test.TestBaseImpl;
 import org.apache.cassandra.index.Index;
 import org.apache.cassandra.index.SecondaryIndexManager;
 import org.apache.cassandra.locator.InetAddressAndPort;
 import org.apache.cassandra.schema.IndexMetadata;
-import org.apache.cassandra.schema.KeyspaceMetadata;
 import org.apache.cassandra.schema.Schema;
-import org.apache.cassandra.schema.TableMetadata;
-import org.apache.cassandra.utils.FBUtilities;
 
 import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
 import static org.apache.cassandra.distributed.api.Feature.NETWORK;
 import static org.apache.cassandra.distributed.test.sai.SAIUtil.waitForIndexQueryable;
-import static org.awaitility.Awaitility.await;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-public class IndexAvailabilityTest extends TestBaseImpl
+public class IndexAvailabilityTest extends IndexTestBase
 {
     private static final String CREATE_KEYSPACE = "CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': %d}";
     private static final String CREATE_TABLE = "CREATE TABLE %s.%s (pk text primary key, v1 int, v2 text) " +
                                                "WITH compaction = {'class' : 'SizeTieredCompactionStrategy', 'enabled' : false }";
     private static final String CREATE_INDEX = "CREATE CUSTOM INDEX %s ON %s.%s(%s) USING 'StorageAttachedIndex'";
-    
-    private static Map<NodeIndex, Index.Status> expectedNodeIndexQueryability = new ConcurrentHashMap<>();
+
+    private static final Map<NodeIndex, Index.Status> expectedNodeIndexQueryability = new ConcurrentHashMap<>();
     private List<String> keyspaces;
     private List<String> indexesPerKs;
 
@@ -118,8 +115,22 @@ public void verifyIndexStatusPropagation() throws Exception
             // other indexes or keyspaces should not be affected
             assertIndexingStatus(cluster);
 
-            // mark ks2 index2 as indexing on node1
-            markIndexBuilding(cluster.get(1), ks2, cf1, index2);
+            // mark ks2 index2 as building on node1
+            markIndexBuilding(cluster.get(1), ks2, cf1, index2, true);
+            // on node2, it observes that node1 ks2.index2 is not queryable
+            waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(1), Index.Status.INITIAL_BUILD_STARTED);
+            // other indexes or keyspaces should not be affected
+            assertIndexingStatus(cluster);
+
+            // mark ks2 index2 as queryable on node1
+            markIndexQueryable(cluster.get(1), ks2, cf1, index2);
+            // on node2, it observes that node1 ks2.index2 is queryable
+            waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            // other indexes or keyspaces should not be affected
+            assertIndexingStatus(cluster);
+
+            // mark ks2 index2 as building on node1
+            markIndexBuilding(cluster.get(1), ks2, cf1, index2, false);
             // on node2, it observes that node1 ks2.index2 is not queryable
             waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(1), Index.Status.FULL_REBUILD_STARTED);
             // other indexes or keyspaces should not be affected
@@ -134,7 +145,7 @@ public void verifyIndexStatusPropagation() throws Exception
             assertIndexingStatus(cluster);
 
             // drop ks2 index2, there should be no ks2 index2 status on all node
-            cluster.schemaChange("DROP INDEX " + ks2 + "." + index2);
+            cluster.schemaChange("DROP INDEX " + ks2 + '.' + index2);
             expectedNodeIndexQueryability.keySet().forEach(k -> {
                 if (k.keyspace.equals(ks2) && k.index.equals(index2))
                     expectedNodeIndexQueryability.put(k, Index.Status.UNKNOWN);
@@ -142,7 +153,7 @@ public void verifyIndexStatusPropagation() throws Exception
             assertIndexingStatus(cluster);
 
             // drop ks3 cf1, there should be no ks3 index1/index2 status
-            cluster.schemaChange("DROP TABLE " + ks3 + "." + cf1);
+            cluster.schemaChange("DROP TABLE " + ks3 + '.' + cf1);
             expectedNodeIndexQueryability.keySet().forEach(k -> {
                 if (k.keyspace.equals(ks3))
                     expectedNodeIndexQueryability.put(k, Index.Status.UNKNOWN);
@@ -234,7 +245,320 @@ private void shouldSkipNonQueryableNode(int nodes, List<Integer>... nonQueryable
         }
     }
 
-    private void executeOnAllCoordinatorsAllConsistencies(Cluster cluster, String statement, int liveReplicas, int num) throws Exception
+    @Test
+    public void testAllowFilteringDuringIndexInitialBuildOn3NodeCluster() throws Exception
+    {
+        testAllowFilteringDuringIndexBuildsOn3NodeCluster(true, Index.Status.INITIAL_BUILD_STARTED);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexFullRebuildOn3NodeCluster() throws Exception
+    {
+        testAllowFilteringDuringIndexBuildsOn3NodeCluster(false, Index.Status.FULL_REBUILD_STARTED);
+    }
+
+    public void testAllowFilteringDuringIndexBuildsOn3NodeCluster(boolean isCreateIndex, Index.Status buildStatus) throws Exception
+    {
+        try (Cluster cluster = init(Cluster.build(3)
+                                           .withConfig(config -> config.with(GOSSIP)
+                                                                                     .with(NETWORK))
+                                           .start()))
+        {
+            String ks2 = "ks2";
+            String table = "tbl";
+            String index1 = "tbl_idx1";
+            String index2 = "tbl_idx2";
+            String vectorIndex = "tbl_vec_idx";
+            keyspaces = List.of(ks2);
+            indexesPerKs = Arrays.asList(index1, index2, vectorIndex);
+
+            cluster.schemaChange(String.format(CREATE_KEYSPACE, ks2, 2));
+            cluster.schemaChange("CREATE TABLE " + ks2 + '.' + table +
+                                 " (pk text, i int, j int, k int, v1 int, v2 int, vec vector<float, 2>, " +
+                                 "PRIMARY KEY((pk, i), j))");
+
+            // Insert test data
+            cluster.coordinator(1).execute(String.format("INSERT INTO %s.%s(pk, i, j, k, v1, v2, vec) VALUES " +
+                                                         "('partition1', 1, 100, 200, 0, 0, [0.5, 1.5])",
+                                                         ks2, table), ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(String.format("INSERT INTO %s.%s(pk, i, j, k, v1, v2, vec) VALUES " +
+                                                         "('partition2', 2, 101, 201, 1, 1, [1.5, 2.5])",
+                                                         ks2, table), ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(String.format("INSERT INTO %s.%s(pk, i, j, k, v1, v2, vec) VALUES " +
+                                                         "('partition3', 1, 102, 202, 0, 1, [2.5, 3.5])",
+                                                         ks2, table), ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(String.format("INSERT INTO %s.%s(pk, i, j, k, v1, v2, vec) VALUES " +
+                                                         "('partition4', 2, 103, 203, 1, 0, [3.5, 4.5])",
+                                                         ks2, table), ConsistencyLevel.QUORUM);
+            cluster.coordinator(1).execute(String.format("INSERT INTO %s.%s(pk, i, j, k, v1, v2, vec) VALUES " +
+                                                         "('partition5', 1, 104, 204, 0, 0, [4.5, 5.5])",
+                                                         ks2, table), ConsistencyLevel.QUORUM);
+
+            // Test queries before any index exists
+            executeOnAllCoordinators(cluster,
+                                     "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     2);
+            // Verify actual results using a direct query
+            Object[][] results = cluster.coordinator(1)
+                                        .execute("SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                                 ConsistencyLevel.LOCAL_QUORUM);
+            assertResultContains(results, Arrays.asList("partition1", "partition5"));
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE);
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT * FROM " + ks2 + '.' + table + " ORDER BY vec ANN OF [1, 1] ALLOW FILTERING",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(String.format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"));
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.GEO_DISTANCE_REQUIRES_INDEX_MESSAGE);
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.GEO_DISTANCE_REQUIRES_INDEX_MESSAGE);
+
+            // Create and verify indexes
+            cluster.schemaChange(String.format(CREATE_INDEX, index1, ks2, table, "v1"));
+            waitForIndexQueryable(cluster, ks2);
+            cluster.forEach(node -> expectedNodeIndexQueryability.put(NodeIndex.create(ks2, index1, node), Index.Status.BUILD_SUCCEEDED));
+            markIndexBuilding(cluster.get(1), ks2, table, index1, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index1, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index1, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index1, cluster.get(1), buildStatus);
+            markIndexBuilding(cluster.get(2), ks2, table, index1, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index1, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index1, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index1, cluster.get(2), buildStatus);
+            markIndexBuilding(cluster.get(3), ks2, table, index1, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index1, cluster.get(3), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index1, cluster.get(3), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index1, cluster.get(3), buildStatus);
+            assertIndexingStatus(cluster, ks2, index1);
+
+            if (isCreateIndex)
+            {
+                executeOnAllCoordinators(cluster,
+                                         "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 ALLOW FILTERING",
+                                         ConsistencyLevel.LOCAL_QUORUM,
+                                         3);
+            }
+            else
+            {
+                assertThatThrownBy(() -> executeOnAllCoordinators(cluster,
+                                                                  "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 ALLOW FILTERING",
+                                                                  ConsistencyLevel.LOCAL_QUORUM,
+                                                                  3))
+                        .hasMessageMatching("^Operation failed - received 0 responses" +
+                                            " and 2 failures: INDEX_NOT_AVAILABLE from .+" +
+                                            " INDEX_NOT_AVAILABLE from .+$");
+            }
+
+            markIndexQueryable(cluster.get(1), ks2, table, index1);
+            waitForIndexingStatus(cluster.get(2), ks2, index1, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(3), ks2, index1, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            markIndexQueryable(cluster.get(2), ks2, table, index1);
+            waitForIndexingStatus(cluster.get(1), ks2, index1, cluster.get(2), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(3), ks2, index1, cluster.get(2), Index.Status.BUILD_SUCCEEDED);
+            markIndexQueryable(cluster.get(3), ks2, table, index1);
+            waitForIndexingStatus(cluster.get(1), ks2, index1, cluster.get(3), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(2), ks2, index1, cluster.get(3), Index.Status.BUILD_SUCCEEDED);
+            assertIndexingStatus(cluster, ks2, index1);
+
+            executeOnAllCoordinators(cluster,
+                                     "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 ALLOW FILTERING",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     3);
+
+            cluster.schemaChange(String.format("CREATE CUSTOM INDEX %s ON %s.%s(vec) USING 'StorageAttachedIndex'",
+                                               vectorIndex, ks2, table));
+            cluster.forEach(node -> expectedNodeIndexQueryability.put(NodeIndex.create(ks2, vectorIndex, node), Index.Status.BUILD_SUCCEEDED));
+            waitForIndexQueryable(cluster, ks2);
+
+            executeOnAllCoordinators(cluster,
+                                     "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     2);
+
+            // Verify actual results using a direct query
+            results = cluster.coordinator(1)
+                             .execute("SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                      ConsistencyLevel.LOCAL_QUORUM);
+            assertResultContains(results, Arrays.asList("partition1", "partition5"));
+
+            executeOnAllCoordinators(cluster,
+                                     "SELECT * FROM " + ks2 + '.' + table + " ORDER BY vec ANN OF [1, 1] LIMIT 10 ALLOW FILTERING",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     5);
+
+            // Create one more index but mark it as building
+            cluster.schemaChange(String.format(CREATE_INDEX, index2, ks2, table, "v2"));
+            markIndexBuilding(cluster.get(1), ks2, table, index2, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index2, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index2, cluster.get(1), buildStatus);
+            markIndexBuilding(cluster.get(2), ks2, table, index2, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index2, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index2, cluster.get(2), buildStatus);
+            markIndexBuilding(cluster.get(3), ks2, table, index2, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, index2, cluster.get(3), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, index2, cluster.get(3), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, index2, cluster.get(3), buildStatus);
+            assertIndexingStatus(cluster);
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT * FROM " + ks2 + '.' + table +
+                                                        " WHERE k > 0 ORDER BY vec ANN OF [1.0, 1.0] LIMIT 10 ALLOW FILTERING",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE);
+
+            // Verify that the query works or not with ALLOW FILTERING or not
+
+            if (isCreateIndex)
+            {
+                executeOnAllCoordinators(cluster,
+                                         "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                         ConsistencyLevel.LOCAL_QUORUM,
+                                         2);
+
+                // Verify actual results using a direct query
+                results = cluster.coordinator(1)
+                                 .execute("SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                          ConsistencyLevel.LOCAL_QUORUM);
+                assertResultContains(results, Arrays.asList("partition1", "partition5"));
+            }
+            else
+            {
+                assertThatThrownBy(() -> executeOnAllCoordinators(cluster,
+                                                                  "SELECT pk FROM " + ks2 + '.' + table + " WHERE v1=0 AND v2=0 ALLOW FILTERING",
+                                                                  ConsistencyLevel.LOCAL_QUORUM,
+                                                                  2)).hasMessageMatching("^Operation failed - received 0 responses" +
+                                                                                         " and 2 failures: INDEX_NOT_AVAILABLE from .+" +
+                                                                                         " INDEX_NOT_AVAILABLE from .+$");
+            }
+
+            // mark the vector index as building, we should not be able to query it yet
+            markIndexBuilding(cluster.get(1), ks2, table, vectorIndex, isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, vectorIndex, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, vectorIndex, cluster.get(1), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, vectorIndex, cluster.get(1), buildStatus);
+            markIndexBuilding(cluster.get(2), ks2, table, vectorIndex,isCreateIndex);
+            waitForIndexingStatus(cluster.get(2), ks2, vectorIndex, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(3), ks2, vectorIndex, cluster.get(2), buildStatus);
+            waitForIndexingStatus(cluster.get(1), ks2, vectorIndex, cluster.get(2), buildStatus);
+            assertIndexingStatus(cluster);
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT * FROM " + ks2 + '.' + table + " ORDER BY vec ANN OF [1, 1] LIMIT 10 ALLOW FILTERING",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining("Operation failed - received 0 responses and 2 failures: INDEX_NOT_AVAILABLE");
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.VECTOR_INDEX_PRESENT_NOT_SUPPORT_GEO_DISTANCE_MESSAGE);
+
+            assertThatThrownBy(() ->
+                               executeOnAllCoordinators(cluster,
+                                                        "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING",
+                                                        ConsistencyLevel.LOCAL_QUORUM,
+                                                        0))
+            .hasMessageContaining(StatementRestrictions.VECTOR_INDEX_PRESENT_NOT_SUPPORT_GEO_DISTANCE_MESSAGE);
+
+            // drop the index that does not support GEO DISTANCE
+            cluster.schemaChange("DROP INDEX IF EXISTS " + ks2 + '.' + vectorIndex);
+            expectedNodeIndexQueryability.keySet().forEach(k -> {
+                if (k.keyspace.equals(ks2) && k.index.equals(vectorIndex))
+                    expectedNodeIndexQueryability.put(k, Index.Status.UNKNOWN);
+            });
+            assertIndexingStatus(cluster);
+
+            // create a new index that supports GEO DISTANCE
+            cluster.schemaChange(String.format("CREATE CUSTOM INDEX %s ON %s.%s(vec) USING 'StorageAttachedIndex' WITH OPTIONS = {'similarity_function' : 'euclidean'}",
+                                               vectorIndex, ks2, table));
+            cluster.forEach(node -> expectedNodeIndexQueryability.put(NodeIndex.create(ks2, vectorIndex, node), Index.Status.BUILD_SUCCEEDED));
+            waitForIndexingStatus(cluster.get(2), ks2, vectorIndex, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(3), ks2, vectorIndex, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(1), ks2, vectorIndex, cluster.get(1), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(2), ks2, vectorIndex, cluster.get(2), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(3), ks2, vectorIndex, cluster.get(2), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(1), ks2, vectorIndex, cluster.get(2), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(2), ks2, vectorIndex, cluster.get(3), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(3), ks2, vectorIndex, cluster.get(3), Index.Status.BUILD_SUCCEEDED);
+            waitForIndexingStatus(cluster.get(1), ks2, vectorIndex, cluster.get(3), Index.Status.BUILD_SUCCEEDED);
+
+            // other indexes or keyspaces should not be affected
+            assertIndexingStatus(cluster);
+
+            executeOnAllCoordinators(cluster,
+                                     "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     0);
+
+            executeOnAllCoordinators(cluster,
+                                     "SELECT pk FROM " + ks2 + '.' + table + " WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING",
+                                     ConsistencyLevel.LOCAL_QUORUM,
+                                     0);
+        }
+    }
+
+    @Test
+    public void testAllowFilteringWithIndexBuildingOn1NodeCluster() throws Exception
+    {
+        try (Cluster cluster = init(Cluster.build(1)
+                                           .withConfig(config -> config.with(GOSSIP)
+                                                                       .with(NETWORK))
+                                           .start()))
+        {
+            String ks2 = "ks2";
+            String cf1 = "cf1";
+            String index2 = "cf1_idx2";
+
+            cluster.schemaChange(String.format(CREATE_KEYSPACE, ks2, 1));
+            cluster.schemaChange(String.format(CREATE_TABLE, ks2, cf1));
+            executeOnAllCoordinators(cluster, "SELECT pk FROM ks2.cf1 WHERE v2='0' ALLOW FILTERING", ConsistencyLevel.LOCAL_QUORUM, 0);
+            cluster.schemaChange(String.format(CREATE_INDEX, index2, ks2, cf1, "v2"));
+            waitForIndexQueryable(cluster, ks2);
+            cluster.forEach(node -> expectedNodeIndexQueryability.put(NodeIndex.create(ks2, index2, node), Index.Status.BUILD_SUCCEEDED));
+
+            executeOnAllCoordinators(cluster, "SELECT pk FROM ks2.cf1 WHERE v2='0'", ConsistencyLevel.LOCAL_QUORUM, 0);
+            executeOnAllCoordinators(cluster, "SELECT pk FROM ks2.cf1 WHERE v2='0' ALLOW FILTERING", ConsistencyLevel.LOCAL_QUORUM, 0);
+
+            // mark ks2 index2 as building on node1
+            markIndexBuilding(cluster.get(1), ks2, cf1, index2, true);
+            // on node2, it observes that node1 ks2.index2 is not queryable
+            waitForIndexingStatus(cluster.get(1), ks2, index2, cluster.get(1), Index.Status.INITIAL_BUILD_STARTED);
+            // other indexes or keyspaces should not be affected
+            assertIndexingStatus(cluster, ks2, index2);
+
+            //executeOnAllCoordinators(cluster, "SELECT pk FROM ks2.cf1 WHERE v2='0'", ConsistencyLevel.LOCAL_QUORUM, 0);
+            executeOnAllCoordinators(cluster, "SELECT pk FROM ks2.cf1 WHERE v2='0' ALLOW FILTERING", ConsistencyLevel.LOCAL_QUORUM, 0);
+        }
+    }
+
+    private void executeOnAllCoordinatorsAllConsistencies(Cluster cluster, String statement, int liveReplicas, int num)
     {
         int allReplicas = cluster.size();
 
@@ -245,58 +569,62 @@ private void executeOnAllCoordinatorsAllConsistencies(Cluster cluster, String st
         executeOnAllCoordinators(cluster, statement, ConsistencyLevel.ALL, liveReplicas >= allReplicas ? num : -1);
     }
 
-    private void executeOnAllCoordinators(Cluster cluster, String query, ConsistencyLevel level, int expected) throws Exception
+    private void executeOnAllCoordinators(Cluster cluster, String query, ConsistencyLevel level, int expected)
     {
         // test different coordinator
         for (int nodeId = 1; nodeId <= cluster.size(); nodeId++)
         {
-            final int node = nodeId;
             if (expected >= 0)
                 assertEquals(expected, cluster.coordinator(nodeId).execute(query, level).length);
             else
             {
                 try
                 {
-                    cluster.coordinator(node).execute(query, level);
+                    cluster.coordinator(nodeId).execute(query, level);
                 }
                 catch (Throwable e)
                 {
-                    assertTrue(e.getClass().getSimpleName().equals("ReadFailureException"));
+                    assertEquals("ReadFailureException", e.getClass().getSimpleName());
                 }
             }
         }
     }
 
-    private void markIndexNonQueryable(IInvokableInstance node, String keyspace, String table, String indexName) throws Exception
+    private void markIndexNonQueryable(IInvokableInstance node, String keyspace, String table, String indexName)
     {
         expectedNodeIndexQueryability.put(NodeIndex.create(keyspace, indexName, node), Index.Status.BUILD_FAILED);
 
         node.runOnInstance(() -> {
-            SecondaryIndexManager sim = Schema.instance.getKeyspaceInstance(keyspace).getColumnFamilyStore(table).indexManager;
+            SecondaryIndexManager sim = java.util.Objects.requireNonNull(Schema.instance.getKeyspaceInstance(keyspace)).getColumnFamilyStore(table).indexManager;
             Index index = sim.getIndexByName(indexName);
             sim.makeIndexNonQueryable(index, Index.Status.BUILD_FAILED);
         });
     }
 
-    private void markIndexQueryable(IInvokableInstance node, String keyspace, String table, String indexName) throws Exception
+    private void markIndexQueryable(IInvokableInstance node, String keyspace, String table, String indexName)
     {
         expectedNodeIndexQueryability.put(NodeIndex.create(keyspace, indexName, node), Index.Status.BUILD_SUCCEEDED);
 
         node.runOnInstance(() -> {
-            SecondaryIndexManager sim = Schema.instance.getKeyspaceInstance(keyspace).getColumnFamilyStore(table).indexManager;
+            SecondaryIndexManager sim = java.util.Objects.requireNonNull(Schema.instance.getKeyspaceInstance(keyspace)).getColumnFamilyStore(table).indexManager;
             Index index = sim.getIndexByName(indexName);
-            sim.makeIndexNonQueryable(index, Index.Status.BUILD_SUCCEEDED);
+            //sim.makeIndexQueryable(index, Index.Status.BUILD_SUCCEEDED);
+            sim.markIndexBuilt(index, true);
         });
     }
 
-    private void markIndexBuilding(IInvokableInstance node, String keyspace, String table, String indexName) throws Exception
+    private void markIndexBuilding(IInvokableInstance node, String keyspace, String table, String indexName, boolean isCreateIndex)
     {
-        expectedNodeIndexQueryability.put(NodeIndex.create(keyspace, indexName, node), Index.Status.FULL_REBUILD_STARTED);
+        if (isCreateIndex)
+            expectedNodeIndexQueryability.put(NodeIndex.create(keyspace, indexName, node), Index.Status.INITIAL_BUILD_STARTED);
+        else
+            expectedNodeIndexQueryability.put(NodeIndex.create(keyspace, indexName, node), Index.Status.FULL_REBUILD_STARTED);
 
         node.runOnInstance(() -> {
-            SecondaryIndexManager sim = Schema.instance.getKeyspaceInstance(keyspace).getColumnFamilyStore(table).indexManager;
+            SecondaryIndexManager sim = java.util.Objects.requireNonNull(Schema.instance.getKeyspaceInstance(keyspace)).getColumnFamilyStore(table).indexManager;
             Index index = sim.getIndexByName(indexName);
-            sim.markIndexesBuilding(Collections.singleton(index), true, false);
+            // KATE double-check this later...
+            sim.markIndexesBuilding(Collections.singleton(index), true, false, isCreateIndex);
         });
     }
 
@@ -341,40 +669,24 @@ private static void assertIndexingStatus(IInvokableInstance node, String keyspac
         }
     }
 
-    private static void waitForIndexingStatus(IInvokableInstance node, String keyspace, String index, IInvokableInstance replica, Index.Status status)
-    {
-        InetAddressAndPort replicaAddressAndPort = getFullAddress(replica);
-        await().atMost(5, TimeUnit.SECONDS)
-               .until(() -> node.callOnInstance(() -> getIndexStatus(keyspace, index, replicaAddressAndPort) == status).booleanValue());
-    }
-
     private static Index.Status getNodeIndexStatus(IInvokableInstance node, String keyspaceName, String indexName, InetAddressAndPort replica)
     {
         return Index.Status.values()[node.callsOnInstance(() -> getIndexStatus(keyspaceName, indexName, replica).ordinal()).call()];
     }
-    
-    private static Index.Status getIndexStatus(String keyspaceName, String indexName, InetAddressAndPort replica)
-    {
-        KeyspaceMetadata keyspace = Schema.instance.getKeyspaceMetadata(keyspaceName);
-        if (keyspace == null)
-            return Index.Status.UNKNOWN;
-
-        TableMetadata table = keyspace.findIndexedTable(indexName).orElse(null);
-        if (table == null)
-            return Index.Status.UNKNOWN;
-
-        SecondaryIndexManager indexManager = Keyspace.openAndGetStore(table).indexManager;
-        
-        return indexManager.getIndexStatus(replica, keyspaceName, indexName);
-    }
 
-    private static InetAddressAndPort getFullAddress(IInvokableInstance node)
+    private void assertResultContains(Object[][] results, List<String> expectedValues)
     {
-        InetAddress address = node.broadcastAddress().getAddress();
-        int port = node.callOnInstance(() -> FBUtilities.getBroadcastAddressAndPort().port);
-        return InetAddressAndPort.getByAddressOverrideDefaults(address, port);
+        Set<String> actualValues = new HashSet<>();
+        for (Object[] row : results)
+            actualValues.add((String) row[0]); // Assuming first column contains the values we're checking
+
+        assertEquals("Result set size doesn't match expected values",
+                     expectedValues.size(), actualValues.size());
+        assertTrue("Results don't contain all expected values: " +
+                   "Expected=" + expectedValues + ", Actual=" + actualValues,
+                   actualValues.containsAll(expectedValues));
     }
-    
+
     private static class NodeIndex
     {
         private final String keyspace;
@@ -411,3 +723,5 @@ public int hashCode()
         }
     }
 }
+
+
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS10Test.java b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS10Test.java
new file mode 100644
index 000000000000..b113651444d3
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS10Test.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.sai.allowfiltering;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.apache.cassandra.config.CassandraRelevantProperties;
+import org.apache.cassandra.distributed.Cluster;
+import org.apache.cassandra.net.MessagingService;
+
+import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
+import static org.apache.cassandra.distributed.api.Feature.NETWORK;
+
+/**
+ * {@link AllowFilteringDuringIndexBuildTester} for clusters with all nodes on mesaging version DS10.
+ */
+public class AllowFilteringDuringIndexBuildAllDS10Test extends AllowFilteringDuringIndexBuildTester
+{
+    @BeforeClass
+    public static void setupCluster() throws Exception
+    {
+        CassandraRelevantProperties.DS_CURRENT_MESSAGING_VERSION.setInt(MessagingService.VERSION_DS_10);
+
+        cluster = init(Cluster.build(NUM_REPLICAS)
+                              .withConfig(config -> config.with(GOSSIP).with(NETWORK))
+                              .start(), RF);
+    }
+
+    @Test
+    public void testAllowFilteringDuringInitialIndexBuildWithAllDS10()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, true, false);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithAllDS10NewTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, true);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithAllDS10ExistingTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, false);
+    }
+}
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS11Test.java b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS11Test.java
new file mode 100644
index 000000000000..426ca4bf50ca
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildAllDS11Test.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.sai.allowfiltering;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.apache.cassandra.config.CassandraRelevantProperties;
+import org.apache.cassandra.distributed.Cluster;
+import org.apache.cassandra.net.MessagingService;
+
+import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
+import static org.apache.cassandra.distributed.api.Feature.NETWORK;
+
+/**
+ * {@link AllowFilteringDuringIndexBuildTester} for clusters with all nodes on mesaging version DS11.
+ */
+public class AllowFilteringDuringIndexBuildAllDS11Test extends AllowFilteringDuringIndexBuildTester
+{
+    @BeforeClass
+    public static void setupCluster() throws Exception
+    {
+        CassandraRelevantProperties.DS_CURRENT_MESSAGING_VERSION.setInt(MessagingService.VERSION_DS_11);
+
+        cluster = init(Cluster.build(NUM_REPLICAS)
+                              .withConfig(config -> config.with(GOSSIP).with(NETWORK))
+                              .start(), RF);
+    }
+
+    @Test
+    public void testAllowFilteringDuringInitialIndexBuildWithAllDS11()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(null, true, false);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithAllDS11NewTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, true);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithAllDS11ExistingTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, false);
+    }
+}
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildDefaultTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildDefaultTest.java
new file mode 100644
index 000000000000..8033beb50718
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildDefaultTest.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.sai.allowfiltering;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.apache.cassandra.distributed.Cluster;
+
+import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
+import static org.apache.cassandra.distributed.api.Feature.NETWORK;
+
+/**
+ * {@link AllowFilteringDuringIndexBuildTester} for clusters with all nodes running the default messaging version.
+ */
+public class AllowFilteringDuringIndexBuildDefaultTest extends AllowFilteringDuringIndexBuildTester
+{
+    @BeforeClass
+    public static void setupCluster() throws Exception
+    {
+        cluster = init(Cluster.build(NUM_REPLICAS)
+                              .withConfig(config -> config.with(GOSSIP).with(NETWORK))
+                              .start(), RF);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInitialBuildWithNewTableShouldFail()
+    {
+            testSelectWithAllowFilteringDuringIndexBuilding(null, true, true);
+    }
+}
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildMixedTest.java b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildMixedTest.java
new file mode 100644
index 000000000000..3a760679ca36
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildMixedTest.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.sai.allowfiltering;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.apache.cassandra.config.CassandraRelevantProperties;
+import org.apache.cassandra.distributed.Cluster;
+import org.apache.cassandra.distributed.test.ByteBuddyUtils;
+import org.apache.cassandra.net.MessagingService;
+
+import static org.apache.cassandra.distributed.api.Feature.GOSSIP;
+import static org.apache.cassandra.distributed.api.Feature.NATIVE_PROTOCOL;
+import static org.apache.cassandra.distributed.api.Feature.NETWORK;
+
+/**
+ * {@link AllowFilteringDuringIndexBuildTester} for clusters with nodes running a mix of DS10 and DS11 messaging versions.
+ */
+public class AllowFilteringDuringIndexBuildMixedTest extends AllowFilteringDuringIndexBuildTester
+{
+    @BeforeClass
+    public static void setupCluster() throws Exception
+    {
+        assert CassandraRelevantProperties.DS_CURRENT_MESSAGING_VERSION.getInt() >= MessagingService.VERSION_DS_11;
+
+        cluster = init(Cluster.build(NUM_REPLICAS)
+                              .withInstanceInitializer(ByteBuddyUtils.BB::install)
+                              .withConfig(config -> config.with(GOSSIP).with(NETWORK).with(NATIVE_PROTOCOL))
+                              .start(), RF);
+    }
+
+    @Test
+    public void testAllowFilteringDuringInitialIndexBuildWithMixedDS10AndDS11()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, true, false);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithMixedDS10AndDS11NewTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, true);
+    }
+
+    @Test
+    public void testAllowFilteringDuringIndexRebuildWithMixedDS10AndDS11ExistingTable()
+    {
+        testSelectWithAllowFilteringDuringIndexBuilding(INDEX_NOT_AVAILABLE_MESSAGE, false, false);
+    }
+}
diff --git a/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildTester.java b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildTester.java
new file mode 100644
index 000000000000..4c5a3d8e51d4
--- /dev/null
+++ b/test/distributed/org/apache/cassandra/distributed/test/sai/allowfiltering/AllowFilteringDuringIndexBuildTester.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.distributed.test.sai.allowfiltering;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.AfterClass;
+
+import org.apache.cassandra.distributed.Cluster;
+import org.apache.cassandra.distributed.api.ConsistencyLevel;
+import org.apache.cassandra.distributed.api.ICoordinator;
+import org.apache.cassandra.distributed.test.index.IndexTestBase;
+import org.apache.cassandra.index.Index;
+import org.assertj.core.api.Assertions;
+
+import static java.lang.String.format;
+
+/**
+ * Distributed tests for ALLOW FILTERING during index build.
+ * </p>
+ * Implementors should provide the {@link #cluster} setup.
+ */
+public abstract class AllowFilteringDuringIndexBuildTester extends IndexTestBase
+{
+    protected static final String INDEX_NOT_AVAILABLE_MESSAGE = "^Operation failed - received 0 responses" +
+                                                                " and 2 failures: INDEX_NOT_AVAILABLE from .+" +
+                                                                " INDEX_NOT_AVAILABLE from .+$";
+    protected static final int NUM_REPLICAS = 2;
+    protected static final int RF = 2;
+
+    private static final AtomicInteger SEQ = new AtomicInteger();
+    protected static Cluster cluster;
+
+    @AfterClass
+    public static void closeCluster()
+    {
+        if (cluster != null)
+            cluster.close();
+    }
+
+    protected void testSelectWithAllowFilteringDuringIndexBuilding(String expectedErrorMessage,
+                                                                   boolean isInitialBuild,
+                                                                   boolean isNewTable)
+    {
+        if (isInitialBuild && isNewTable)
+            throw new IllegalArgumentException("Initial build cannot happen with a new table");
+
+        String table = "table_" + SEQ.getAndIncrement();
+        String index = table + "_idx";
+
+        cluster.schemaChange(format("CREATE TABLE %s.%s (k int PRIMARY KEY, n int, v vector<float, 2>)", KEYSPACE, table));
+        cluster.schemaChange(format("CREATE CUSTOM INDEX %s ON %s.%s(n) USING 'StorageAttachedIndex'", index, KEYSPACE, table));
+
+        Index.Status expectedStatus = isInitialBuild ? Index.Status.INITIAL_BUILD_STARTED : Index.Status.FULL_REBUILD_STARTED;
+
+        for (int i = 1; i <= cluster.size(); i++)
+            markIndexBuilding(cluster.get(i), KEYSPACE, table, index, isInitialBuild, isNewTable);
+
+        for (int i = 1; i <= cluster.size(); i++)
+            for (int j = 1; j <= cluster.size(); j++)
+                waitForIndexingStatus(cluster.get(i), KEYSPACE, index, cluster.get(j), expectedStatus);
+
+        String select = format("SELECT * FROM %s.%s WHERE n = 1 ALLOW FILTERING", KEYSPACE, table);
+
+        for (int i = 1; i <= cluster.size(); i++)
+        {
+            ICoordinator coordinator = cluster.coordinator(i);
+            if (expectedErrorMessage == null)
+            {
+                coordinator.execute(select, ConsistencyLevel.ONE);
+            }
+            else
+            {
+                Assertions.assertThatThrownBy(() -> coordinator.execute(select, ConsistencyLevel.ONE))
+                          .hasMessageMatching(expectedErrorMessage);
+            }
+        }
+
+        cluster.schemaChange(format("DROP TABLE IF EXISTS %s.%s", KEYSPACE, table));
+    }
+}
diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java
index 63bf2c8c6b22..4dfd8596948f 100644
--- a/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java
+++ b/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java
@@ -1156,6 +1156,8 @@ public void testIndexQueriesWithIndexNotReady()
         {
             execute("DROP index " + KEYSPACE + ".testIndex");
         }
+
+        execute("SELECT value FROM %s WHERE value = 2 ALLOW FILTERING");
     }
 
     @Test // A Bad init could leave an index only accepting reads
diff --git a/test/unit/org/apache/cassandra/index/AllIndexImplementationsTest.java b/test/unit/org/apache/cassandra/index/AllIndexImplementationsTest.java
index b815e4213ca3..073b393ef6d4 100644
--- a/test/unit/org/apache/cassandra/index/AllIndexImplementationsTest.java
+++ b/test/unit/org/apache/cassandra/index/AllIndexImplementationsTest.java
@@ -19,7 +19,9 @@
 import java.util.LinkedList;
 import java.util.List;
 
+import org.junit.After;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -29,6 +31,9 @@
 import org.apache.cassandra.index.internal.CassandraIndex;
 import org.apache.cassandra.index.sai.StorageAttachedIndex;
 import org.apache.cassandra.index.sasi.SASIIndex;
+import org.apache.cassandra.index.sasi.SASIIndexBuilder;
+import org.apache.cassandra.inject.Injections;
+import org.apache.cassandra.inject.InvokePointBuilder;
 
 import static org.apache.cassandra.cql3.restrictions.StatementRestrictions.INDEX_DOES_NOT_SUPPORT_DISJUNCTION;
 import static org.apache.cassandra.cql3.restrictions.StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE;
@@ -48,17 +53,74 @@ public class AllIndexImplementationsTest extends CQLTester
     @Parameterized.Parameter(2)
     public String createIndexQuery;
 
-    @Parameterized.Parameters(name = "{0}")
+    @Parameterized.Parameter(3)
+    public boolean duringInitialBuild;
+
+    private Injections.Barrier blockIndexBuildInjection;
+
+    @Parameterized.Parameters(name = "index={0} during_initial_build={3}")
     public static List<Object[]> parameters()
     {
         List<Object[]> parameters = new LinkedList<>();
-        parameters.add(new Object[]{ "none", null, null });
-        parameters.add(new Object[]{ "legacy", CassandraIndex.class, "CREATE INDEX ON %%s(%s)" });
-        parameters.add(new Object[]{ "SASI", SASIIndex.class, "CREATE CUSTOM INDEX ON %%s(%s) USING 'org.apache.cassandra.index.sasi.SASIIndex'" });
-        parameters.add(new Object[]{ "SAI", StorageAttachedIndex.class, "CREATE CUSTOM INDEX ON %%s(%s) USING 'StorageAttachedIndex'" });
+
+        // without any indexes
+        parameters.add(new Object[]{ "none", null, null, false });
+
+        // for each known index implementation, before and after finishing the initial build
+        for (boolean duringInitialBuild : new boolean[]{ false, true })
+        {
+            parameters.add(new Object[]{ "legacy",
+                                         CassandraIndex.class,
+                                         "CREATE INDEX ON %%s(%s)",
+                                         duringInitialBuild });
+            parameters.add(new Object[]{ "SASI",
+                                         SASIIndex.class,
+                                         "CREATE CUSTOM INDEX ON %%s(%s) USING 'org.apache.cassandra.index.sasi.SASIIndex'",
+                                         duringInitialBuild });
+            parameters.add(new Object[]{ "SAI",
+                                         StorageAttachedIndex.class,
+                                         "CREATE CUSTOM INDEX ON %%s(%s) USING 'StorageAttachedIndex'",
+                                         duringInitialBuild });
+        }
         return parameters;
     }
 
+    @Before
+    public void setupBlockIndexBuildInjection() throws Throwable
+    {
+        if (!duringInitialBuild)
+            return;
+
+        if (StorageAttachedIndex.class.equals(indexClass))
+        {
+            blockIndexBuildInjection = blockInitialBuildInjection(indexClass, "startInitialBuild");
+        }
+        else if (CassandraIndex.class.equals(indexClass))
+        {
+            blockIndexBuildInjection = blockInitialBuildInjection(indexClass, "buildBlocking");
+        }
+        else if (SASIIndex.class.equals(indexClass))
+        {
+            blockIndexBuildInjection = blockInitialBuildInjection(SASIIndexBuilder.class, "build");
+        }
+        else
+        {
+            throw new AssertionError("Unsupported index class: " + indexClass);
+        }
+
+        Injections.inject(blockIndexBuildInjection);
+    }
+
+    @After
+    public void teardownBlockIndexBuildInjection()
+    {
+        if (blockIndexBuildInjection != null)
+        {
+            blockIndexBuildInjection.countDown();
+            blockIndexBuildInjection.disable();
+        }
+    }
+
     @Test
     public void testDisjunction()
     {
@@ -67,7 +129,11 @@ public void testDisjunction()
         boolean indexSupportsDisjuntion = StorageAttachedIndex.class.equals(indexClass);
         boolean hasIndex = createIndexQuery != null;
         if (hasIndex)
-            createIndex(String.format(createIndexQuery, 'a'));
+        {
+            createIndexAsync(String.format(createIndexQuery, 'a'));
+            if (!duringInitialBuild)
+                waitForTableIndexesQueryable();
+        }
 
         execute("INSERT INTO %s (pk, a, b) VALUES (?, ?, ?)", 1, 1, 1);
         execute("INSERT INTO %s (pk, a, b) VALUES (?, ?, ?)", 2, 2, 2);
@@ -98,7 +164,11 @@ public void testDisjunction()
 
         // create a second index in the remaining column, so all columns are indexed
         if (hasIndex)
-            createIndex(String.format(createIndexQuery, 'b'));
+        {
+            createIndexAsync(String.format(createIndexQuery, 'b'));
+            if (!duringInitialBuild)
+                waitForTableIndexesQueryable();
+        }
 
         // test with all columns indexed
         assertDisjunction("a = 1 OR a = 2",
@@ -141,8 +211,11 @@ private void assertDisjunction(String restrictions,
     {
         // without ALLOW FILTERING
         String query = "SELECT pk FROM %s WHERE " + restrictions;
+
         if (requiresFiltering)
             assertInvalidThrowMessage(error, InvalidRequestException.class, query);
+        else if (duringInitialBuild)
+            assertInvalidThrow(IndexNotAvailableException.class, query);
         else
             assertRowsIgnoringOrder(execute(query), rows);
 
@@ -154,4 +227,12 @@ private void assertDisjunction(String restrictions,
         Index.QueryPlan plan = parseReadCommand(query).indexQueryPlan();
         Assert.assertEquals(shouldUseIndexes, plan != null);
     }
+
+    private static Injections.Barrier blockInitialBuildInjection(Class<?> indexClass, String methodName)
+    {
+        return Injections.newBarrier("block_index_build", 2, false)
+                         .add(InvokePointBuilder.newInvokePoint().onClass(indexClass)
+                                                .onMethod(methodName))
+                         .build();
+    }
 }
diff --git a/test/unit/org/apache/cassandra/index/CustomIndexTest.java b/test/unit/org/apache/cassandra/index/CustomIndexTest.java
index f1155a82512a..7057533a5b2f 100644
--- a/test/unit/org/apache/cassandra/index/CustomIndexTest.java
+++ b/test/unit/org/apache/cassandra/index/CustomIndexTest.java
@@ -1620,6 +1620,12 @@ public QueryPlan queryPlanFor(RowFilter rowFilter)
                 throw new UnsupportedOperationException();
             }
 
+            @Override
+            public QueryPlan queryPlanForIndices(RowFilter rowFilter, Set<Index> indexes)
+            {
+                throw new UnsupportedOperationException();
+            }
+
             @Override
             public SSTableFlushObserver getFlushObserver(Descriptor descriptor, LifecycleNewTracker tracker, TableMetadata tableMetadata, long keyCount)
             {
diff --git a/test/unit/org/apache/cassandra/index/sai/cql/AllowFilteringTest.java b/test/unit/org/apache/cassandra/index/sai/cql/AllowFilteringTest.java
index 181f74de95f4..cdd777e717af 100644
--- a/test/unit/org/apache/cassandra/index/sai/cql/AllowFilteringTest.java
+++ b/test/unit/org/apache/cassandra/index/sai/cql/AllowFilteringTest.java
@@ -17,12 +17,26 @@
  */
 package org.apache.cassandra.index.sai.cql;
 
+import java.util.Arrays;
+import java.util.regex.Pattern;
+
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.exceptions.InvalidRequestException;
+import org.apache.cassandra.exceptions.ReadFailureException;
+import org.apache.cassandra.exceptions.RequestFailureException;
 import org.junit.Test;
 
 import org.apache.cassandra.cql3.restrictions.StatementRestrictions;
 import org.apache.cassandra.index.sai.SAITester;
 import org.apache.cassandra.index.sai.StorageAttachedIndex;
-
+import org.apache.cassandra.inject.Injections;
+import org.apache.cassandra.inject.InvokePointBuilder;
+import org.apache.cassandra.service.ClientWarn;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ListAssert;
+
+import static java.lang.String.format;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertNotNull;
 
 /**
@@ -30,12 +44,148 @@
  */
 public class AllowFilteringTest extends SAITester
 {
+    private static final Pattern PATTERN = Pattern.compile("The query won't use the indexes \\[.*] on endpoints.*");
+    private final Injections.Barrier blockIndexBuild = Injections.newBarrier("block_index_build", 2, false)
+                                                                 .add(InvokePointBuilder.newInvokePoint()
+                                                                 .onClass(StorageAttachedIndex.class)
+                                                                 .onMethod("startInitialBuild"))
+                                                                 .build();
+
+    @Test
+    public void testAllowFilteringDuringIndexBuild() throws Throwable
+    {
+        createTable("CREATE TABLE %s (pk text, i int, j int, k int, vec vector<float, 2>, PRIMARY KEY((pk, i), j))");
+        execute("INSERT INTO %s (pk, i, j, k, vec) VALUES ('partition1', 1, 100, 200, [0.5, 1.5])");
+        Injections.inject(blockIndexBuild);
+
+        // 1. Queries before index creation
+
+        assertInvalidThrowMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE k=0");
+        execute("SELECT * FROM %s WHERE k=0 ALLOW FILTERING");
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1, 1] ALLOW FILTERING WITH ann_options = {}");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1, 1] ALLOW FILTERING");
+
+        String idx = createIndexAsync(format("CREATE CUSTOM INDEX ON %%s(k) USING '%s'", StorageAttachedIndex.class.getName()));
+        String idx2 = createIndexAsync(format("CREATE CUSTOM INDEX ON %%s(vec) USING '%s'", StorageAttachedIndex.class.getName()));
+
+        // 2. Queries during index build - as there is already index and AF is not an option,
+        // it just complains the index is not available from now on.
+
+        assertInvalidThrowMessage("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE",
+                                  ReadFailureException.class,
+                                  "SELECT * FROM %s WHERE k=0");
+
+        assertInvalidThrowMessage("SAI based ORDER BY clause requires a LIMIT that is not greater than 1000. LIMIT was NO LIMIT",
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1, 1] ALLOW FILTERING WITH ann_options = {}");
+
+        assertInvalidThrowMessage("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE",
+                                  ReadFailureException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1, 1] LIMIT 10 ALLOW FILTERING");
+
+        execute("SELECT * FROM %s WHERE k=0 ALLOW FILTERING");
+
+        // A warning was emitted because the index is not yet available, and we fall back to using ALLOW FILTERING
+        assertRows(row("partition1", 1, 100, 200, Arrays.asList(0.5f, 1.5f)))
+                .hasSize(1)
+                .anyMatch(warning -> PATTERN.matcher(warning).matches());
+
+        blockIndexBuild.countDown();
+        blockIndexBuild.disable();
+        waitForIndexQueryable(idx);
+        waitForIndexQueryable(idx2);
+
+        // 3. Queries after index creation
+
+        execute("SELECT * FROM %s WHERE k=0");
+        execute("SELECT * FROM %s WHERE k=0 ALLOW FILTERING");
+        assertInvalidThrowMessage("SAI based ORDER BY clause requires a LIMIT that is not greater than 1000. LIMIT was NO LIMIT",
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1, 1] ALLOW FILTERING WITH ann_options = {}");
+        execute("SELECT * FROM %s ORDER BY vec ANN OF [1, 1] LIMIT 10 ALLOW FILTERING");
+    }
+
+    private ListAssert<String> assertRows(Object[]... rows)
+    {
+        ClientWarn.instance.captureWarnings();
+        CQLTester.disablePreparedReuseForTest();
+        assertRows(execute("SELECT * FROM %s WHERE k=200 ALLOW FILTERING"), rows);
+        ListAssert<String> assertion = Assertions.assertThat(ClientWarn.instance.getWarnings());
+        ClientWarn.instance.resetWarnings();
+        return assertion;
+    }
+
+    @Test
+    public void testAllowFilteringGeoDistance() throws Throwable
+    {
+        createTable("CREATE TABLE %s (pk text, i int, j int, k int, vec vector<float, 2>, PRIMARY KEY((pk, i), j))");
+        Injections.inject(blockIndexBuild);
+
+        // 1. Queries before index creation
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000"))
+        .hasMessage(StatementRestrictions.GEO_DISTANCE_REQUIRES_INDEX_MESSAGE)
+        .isInstanceOf(InvalidRequestException.class);
+
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING"))
+        .hasMessage(StatementRestrictions.GEO_DISTANCE_REQUIRES_INDEX_MESSAGE)
+        .isInstanceOf(InvalidRequestException.class);
+
+        String idx = createIndexAsync(format("CREATE CUSTOM INDEX ON %%s(vec) USING '%s'", StorageAttachedIndex.class.getName()));
+
+        // 2. Queries during not applicable index build.
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING"))
+        .hasMessage(StatementRestrictions.VECTOR_INDEX_PRESENT_NOT_SUPPORT_GEO_DISTANCE_MESSAGE)
+        .isInstanceOf(InvalidRequestException.class);
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING"))
+        .hasMessage(StatementRestrictions.VECTOR_INDEX_PRESENT_NOT_SUPPORT_GEO_DISTANCE_MESSAGE)
+        .isInstanceOf(InvalidRequestException.class);
+
+        execute(format("DROP INDEX IF EXISTS %s.%s", KEYSPACE, idx));
+
+        // 3. Queries during valid index build - as there is already index and AF is not an option,
+        // it just complains the index is not available from now on.
+        idx = createIndexAsync("CREATE CUSTOM INDEX ON %s(vec) USING 'StorageAttachedIndex' WITH OPTIONS = {'similarity_function' : 'euclidean'}");
+
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000"))
+        .hasMessageContaining("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE")
+        .isInstanceOf(RequestFailureException.class);
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000"))
+        .hasMessageContaining("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE")
+        .isInstanceOf(RequestFailureException.class);
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING"))
+        .hasMessageContaining("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE")
+        .isInstanceOf(RequestFailureException.class);
+        assertThatThrownBy(() -> execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING"))
+        .hasMessageContaining("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE")
+        .isInstanceOf(RequestFailureException.class);
+
+        // 4. Queries after index creation
+
+        blockIndexBuild.countDown();
+        blockIndexBuild.disable();
+        waitForIndexQueryable(idx);
+
+        execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000");
+        execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000");
+
+        // ALLOW FILTERING is here, but we use the index
+        execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING");
+        execute( "SELECT pk FROM %s WHERE GEO_DISTANCE(vec, [1, 1]) < 1000 ALLOW FILTERING");
+    }
+
     @Test
     public void testAllowFilteringOnFirstClusteringKeyColumn()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, c3 int, v1 int, " +
                     "PRIMARY KEY ((k1, k2), c1, c2, c3))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c1) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c1) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE c1=0", false);
@@ -79,7 +229,7 @@ public void testAllowFilteringOnNotFirstClusteringKeyColumn()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, c3 int, c4 int, v1 int, " +
                     "PRIMARY KEY ((k1, k2), c1, c2, c3, c4))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c3) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c3) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE c3=0", false);
@@ -124,8 +274,8 @@ public void testAllowFilteringOnMultipleClusteringKeyColumns()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, c3 int, c4 int, v1 int, " +
                     "PRIMARY KEY ((k1, k2), c1, c2, c3, c4))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c2) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c4) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c2) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c4) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE c2=0 AND c4=0", false);
@@ -171,7 +321,7 @@ public void testAllowFilteringOnMultipleClusteringKeyColumns()
     public void testAllowFilteringOnSingleRegularColumn()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, v1 int, v2 int, PRIMARY KEY ((k1, k2), c1, c2))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE v1=0", false);
@@ -214,8 +364,8 @@ public void testAllowFilteringOnMultipleRegularColumns()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, v1 int, v2 int, v3 int, " +
                     "PRIMARY KEY ((k1, k2), c1, c2))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(v2) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(v2) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE v1=0 AND v2=0", false);
@@ -261,10 +411,10 @@ public void testAllowFilteringOnClusteringAndRegularColumns()
     {
         createTable("CREATE TABLE %s (k1 int, k2 int, c1 int, c2 int, c3 int, c4 int, v1 int, v2 int, v3 int, " +
                     "PRIMARY KEY ((k1, k2), c1, c2, c3, c4))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c2) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c4) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(v2) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c2) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c4) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(v1) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(v2) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // with only index restrictions
         test("SELECT * FROM %s WHERE c2=0 AND c4=0 AND v1=0 AND v2=0", false);
@@ -357,28 +507,28 @@ private void test(String query, boolean requiresAllowFiltering)
     public void testUnsupportedIndexRestrictions()
     {
         createTable("CREATE TABLE %s (a text, b text, c text, d text, PRIMARY KEY (a, b))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
 
         execute("INSERT INTO %s (a, b, c, d) VALUES ('Test1', 'Test1', 'Test1', 'Test1')");
         execute("INSERT INTO %s (a, b, c, d) VALUES ('Test2', 'Test2', 'Test2', 'Test2')");
         execute("INSERT INTO %s (a, b, c, d) VALUES ('Test3', 'Test3', 'Test3', 'Test3')");
 
         // Single restriction
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "b"), "SELECT * FROM %s WHERE b > 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "c"), "SELECT * FROM %s WHERE c > 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "d"), "SELECT * FROM %s WHERE d > 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'b'), "SELECT * FROM %s WHERE b > 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'c'), "SELECT * FROM %s WHERE c > 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'd'), "SELECT * FROM %s WHERE d > 'Test'");
 
         // Supported and unsupported restriction
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "b"), "SELECT * FROM %s WHERE b > 'Test' AND c = 'Test1'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "c"), "SELECT * FROM %s WHERE c > 'Test' AND d = 'Test1'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "d"), "SELECT * FROM %s WHERE d > 'Test' AND b = 'Test1'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'b'), "SELECT * FROM %s WHERE b > 'Test' AND c = 'Test1'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'c'), "SELECT * FROM %s WHERE c > 'Test' AND d = 'Test1'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'd'), "SELECT * FROM %s WHERE d > 'Test' AND b = 'Test1'");
 
         // Two unsupported restrictions
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "b"), "SELECT * FROM %s WHERE b > 'Test' AND b < 'Test3'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_MULTI, "[b, c]"), "SELECT * FROM %s WHERE c > 'Test' AND b < 'Test3'");
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_MULTI, "[b, d]"), "SELECT * FROM %s WHERE d > 'Test' AND b < 'Test3'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, 'b'), "SELECT * FROM %s WHERE b > 'Test' AND b < 'Test3'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_MULTI, "[b, c]"), "SELECT * FROM %s WHERE c > 'Test' AND b < 'Test3'");
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_MULTI, "[b, d]"), "SELECT * FROM %s WHERE d > 'Test' AND b < 'Test3'");
 
         // The same queries with ALLOW FILTERING should work
 
@@ -411,45 +561,143 @@ public void testUnsupportedIndexRestrictions()
     public void testIndexedColumnDoesNotSupportLikeRestriction()
     {
         createTable("CREATE TABLE %s (a text, b text, c text, d text, PRIMARY KEY (a, b))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // LIKE restriction
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, "b"), "SELECT * FROM %s WHERE b LIKE 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, "c"), "SELECT * FROM %s WHERE c LIKE 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, "d"), "SELECT * FROM %s WHERE d LIKE 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, 'b'), "SELECT * FROM %s WHERE b LIKE 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, 'c'), "SELECT * FROM %s WHERE c LIKE 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_LIKE_MESSAGE, 'd'), "SELECT * FROM %s WHERE d LIKE 'Test'");
     }
 
     @Test
     public void testIndexedColumnDoesNotSupportAnalyzerRestriction()
     {
         createTable("CREATE TABLE %s (a text, b text, c text, d text, PRIMARY KEY (a, b))");
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
-        createIndex(String.format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(b) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(c) USING '%s'", StorageAttachedIndex.class.getName()));
+        createIndex(format("CREATE CUSTOM INDEX ON %%s(d) USING '%s'", StorageAttachedIndex.class.getName()));
 
         // Analyzer restriction
-        assertInvalidMessage(String.format(": restriction is only supported on properly indexed columns. a : 'Test' is not valid."), "SELECT * FROM %s WHERE a : 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'b'), "SELECT * FROM %s WHERE b : 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'c'), "SELECT * FROM %s WHERE c : 'Test'");
-        assertInvalidMessage(String.format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'd'), "SELECT * FROM %s WHERE d : 'Test'");
+        assertInvalidMessage(": restriction is only supported on properly indexed columns. a : 'Test' is not valid.", "SELECT * FROM %s WHERE a : 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'b'), "SELECT * FROM %s WHERE b : 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'c'), "SELECT * FROM %s WHERE c : 'Test'");
+        assertInvalidMessage(format(StatementRestrictions.INDEX_DOES_NOT_SUPPORT_ANALYZER_MATCHES_MESSAGE, 'd'), "SELECT * FROM %s WHERE d : 'Test'");
     }
 
     @Test
-    public void testQueryRequiresFilteringButHasANNRestriction()
+    public void testQueryRequiresFilteringButHasANNRestriction() throws Throwable
     {
         createTable("CREATE TABLE %s (pk text, i int, j int, k int, vec vector<float, 3>, PRIMARY KEY((pk, i), j))");
-        createIndex("CREATE CUSTOM INDEX ON %s(vec) USING 'StorageAttachedIndex'");
+        Injections.inject(blockIndexBuild);
+
+        // 1. Queries before index creation
+
+        // Ordering on non-clustering column vec requires the column to be indexed.
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1,1,1] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1,1,1] LIMIT 10 ALLOW FILTERING;");
+
+        // Below changes after we add index to different requirement, not sure if we want/can easily improve that
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE j > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE j > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' AND i > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        assertInvalidThrowMessage(format(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_INDEX_MESSAGE, "vec"),
+                                  InvalidRequestException.class,
+                                  "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' AND i > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        // 2. Queries during index build - as there is already index and AF is not an option,
+        // it just complains the index is not available from now on.
+
+        String idx = createIndexAsync("CREATE CUSTOM INDEX ON %s(vec) USING 'StorageAttachedIndex'");
+
+        assertInvalidThrowMessage("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE", ReadFailureException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1,1,1] LIMIT 10;");
+
+        // Should not fail because allow filtering is set but not required
+        assertInvalidThrowMessage("Operation failed - received 0 responses and 1 failures: INDEX_NOT_AVAILABLE", ReadFailureException.class,
+                                  "SELECT * FROM %s ORDER BY vec ANN OF [1,1,1] LIMIT 10 ALLOW FILTERING;");
+
+        // Do not recommend ALLOW FILTERING for non-primary key, non clustering column restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        // Do not let ALLOW FILTERING to lead to query execution for non-primary key, non clustering column restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        // Do not recommend ALLOW FILTERING for clustering column restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE j > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        // Do not let ALLOW FILTERING lead to query execution for clustering column restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE j > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        // Do not recommend ALLOW FILTERING for partial partition key restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        // Do not let ALLOW FILTERING lead to query execution for partial partition key restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        // Do not recommend ALLOW FILTERING for complete partition key restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' AND i > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
+
+        // Do not let ALLOW FILTERING lead to query execution for complete partition key restrictions
+        assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
+                             "SELECT * FROM %s WHERE pk > 'A' AND pk < 'C' AND i > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
+
+        blockIndexBuild.countDown();
+        blockIndexBuild.disable();
+        waitForIndexQueryable(idx);
+
+        // 3. Queries after index creation
 
         // Should not fail because allow filtering is set but not required
         assertRows(execute("SELECT * FROM %s ORDER BY vec ANN OF [1,1,1] LIMIT 10 ALLOW FILTERING;"));
 
-        // Do not recommend ALLOW FILTERING for non primary key, non clustering column restrictions
+        // Do not recommend ALLOW FILTERING for non-primary key, non clustering column restrictions
         assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
                              "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10;");
 
-        // Do not let ALLOW FILTERING to lead to query execution for non primary key, non clustering column restrictions
+        // Do not let ALLOW FILTERING to lead to query execution for non-primary key, non clustering column restrictions
         assertInvalidMessage(StatementRestrictions.NON_CLUSTER_ORDERING_REQUIRES_ALL_RESTRICTED_NON_PARTITION_KEY_COLUMNS_INDEXED_MESSAGE,
                              "SELECT * FROM %s WHERE k > 0 ORDER BY vec ANN OF [2.5, 3.5, 4.5] LIMIT 10 ALLOW FILTERING;");
 
@@ -493,7 +741,7 @@ public void testMapRangeQueries()
         execute("INSERT INTO %s (partition, item_cost) VALUES (3, {'apple': 3, 'orange': 1})");
 
         // Gen an ALLOW FILTERING recommendation.
-        assertInvalidMessage(String.format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "item_cost"),
+        assertInvalidMessage(format(StatementRestrictions.HAS_UNSUPPORTED_INDEX_RESTRICTION_MESSAGE_SINGLE, "item_cost"),
                              "SELECT partition FROM %s WHERE item_cost['apple'] < 6");
 
         // Show that filtering works correctly
diff --git a/test/unit/org/apache/cassandra/locator/AssureSufficientLiveNodesTest.java b/test/unit/org/apache/cassandra/locator/AssureSufficientLiveNodesTest.java
index 2b84a5f3cf31..3cfa97f1face 100644
--- a/test/unit/org/apache/cassandra/locator/AssureSufficientLiveNodesTest.java
+++ b/test/unit/org/apache/cassandra/locator/AssureSufficientLiveNodesTest.java
@@ -150,7 +150,7 @@ public void addDatacenterShouldNotCausesUnavailableWithEachQuorumTest() throws T
             // alter to
             KeyspaceParams.nts(DC1, 3, DC2, 3),
             // test
-            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, EACH_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE)
+            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, EACH_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE, false)
         );
     }
 
@@ -183,7 +183,7 @@ public void addDatacenterShouldNotCausesUnavailableWithQuorumTest() throws Throw
             // alter to
             KeyspaceParams.nts(DC1, 3, DC2, 3),
             // test
-            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, QUORUM, NeverSpeculativeRetryPolicy.INSTANCE)
+            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, QUORUM, NeverSpeculativeRetryPolicy.INSTANCE, false)
         );
         raceOfReplicationStrategyTest(
             // init. The # of live endpoints is 3 = 2 + 1
@@ -191,7 +191,7 @@ public void addDatacenterShouldNotCausesUnavailableWithQuorumTest() throws Throw
             // alter to. (3 + 3) / 2 + 1 > 3
             KeyspaceParams.nts(DC1, 2, DC2, 1, DC3, 3),
             // test
-            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, QUORUM, NeverSpeculativeRetryPolicy.INSTANCE)
+            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, QUORUM, NeverSpeculativeRetryPolicy.INSTANCE, false)
         );
     }
 
@@ -215,7 +215,7 @@ public void raceOnRemoveDatacenterNotCausesUnavailable() throws Throwable
             // alter to
             KeyspaceParams.nts(DC1, 3),
             // test
-            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, EACH_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE)
+            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, EACH_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE, false)
         );
     }
 
@@ -239,7 +239,7 @@ public void increaseReplicationFactorShouldNotCausesUnavailableTest() throws Thr
             // alter to
             KeyspaceParams.nts(DC1, 3),
             // test
-            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, LOCAL_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE)
+            keyspace -> ReplicaPlans.forRead(keyspace, tk, null, LOCAL_QUORUM, NeverSpeculativeRetryPolicy.INSTANCE, false)
         );
     }
 
diff --git a/test/unit/org/apache/cassandra/locator/ReplicaPlansTest.java b/test/unit/org/apache/cassandra/locator/ReplicaPlansTest.java
index 486db68b5073..a0bedf122646 100644
--- a/test/unit/org/apache/cassandra/locator/ReplicaPlansTest.java
+++ b/test/unit/org/apache/cassandra/locator/ReplicaPlansTest.java
@@ -122,11 +122,11 @@ public void testFilterByAffinity() throws UnknownHostException
         Token token = new Murmur3Partitioner.LongToken(0);
 
         Keyspace keyspace1 = keyspaceWithSnitch(KEYSPACE1, filterByKeyspaceAffinitySnitch);
-        ReplicaPlan.ForTokenRead plan1 = ReplicaPlans.forRead(keyspace1, token, null, ANY, NeverSpeculativeRetryPolicy.INSTANCE);
+        ReplicaPlan.ForTokenRead plan1 = ReplicaPlans.forRead(keyspace1, token, null, ANY, NeverSpeculativeRetryPolicy.INSTANCE, false);
         assertEndpointsMatchKeyspaceAffinity(KEYSPACE1, plan1.contacts());
 
         Keyspace keyspace2 = keyspaceWithSnitch(KEYSPACE2, filterByKeyspaceAffinitySnitch);
-        ReplicaPlan.ForTokenRead plan2 = ReplicaPlans.forRead(keyspace2, token, null, ANY, NeverSpeculativeRetryPolicy.INSTANCE);
+        ReplicaPlan.ForTokenRead plan2 = ReplicaPlans.forRead(keyspace2, token, null, ANY, NeverSpeculativeRetryPolicy.INSTANCE, false);
         assertEndpointsMatchKeyspaceAffinity(KEYSPACE2, plan2.contacts());
     }
 
diff --git a/test/unit/org/apache/cassandra/service/reads/range/EndpointGroupingRangeCommandIteratorTest.java b/test/unit/org/apache/cassandra/service/reads/range/EndpointGroupingRangeCommandIteratorTest.java
index 0ffcc79038cd..1ffad426a947 100644
--- a/test/unit/org/apache/cassandra/service/reads/range/EndpointGroupingRangeCommandIteratorTest.java
+++ b/test/unit/org/apache/cassandra/service/reads/range/EndpointGroupingRangeCommandIteratorTest.java
@@ -41,7 +41,6 @@
 import org.apache.cassandra.exceptions.ConfigurationException;
 import org.apache.cassandra.locator.ReplicaPlan;
 import org.apache.cassandra.schema.KeyspaceParams;
-import org.apache.cassandra.service.QueryInfoTracker;
 import org.apache.cassandra.utils.CloseableIterator;
 
 import static org.apache.cassandra.service.QueryInfoTracker.*;
@@ -155,7 +154,7 @@ private static NonGroupingRangeCommandIterator tokenOrderIterator(PartitionRange
     private static CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlanIterator(PartitionRangeReadCommand command)
     {
         AbstractBounds<PartitionPosition> keyRange = command.dataRange().keyRange();
-        CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlans = new ReplicaPlanIterator(keyRange, null, keyspace, ConsistencyLevel.ONE);
+        CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlans = new ReplicaPlanIterator(keyRange, null, keyspace, ConsistencyLevel.ONE, command.rowFilter().allowFiltering);
         return new ReplicaPlanMerger(replicaPlans, keyspace, ConsistencyLevel.ONE);
     }
 }
diff --git a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java
index 6b313d41e1fd..a93d5a74db7a 100644
--- a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java
+++ b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java
@@ -71,7 +71,7 @@ public void testRangeCountWithRangeMerge()
         for (int i = 0; i + 1 < tokens.size(); i++)
         {
             Range<PartitionPosition> range = Range.makeRowRange(tokens.get(i), tokens.get(i + 1));
-            ranges.add(ReplicaPlans.forRangeRead(keyspace, null, ConsistencyLevel.ONE, range, 1));
+            ranges.add(ReplicaPlans.forRangeRead(keyspace, null, ConsistencyLevel.ONE, range, 1, false));
             vnodeCount++;
         }
 
@@ -165,7 +165,7 @@ private static CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlanIterator(A
                                                                                    Keyspace keyspace,
                                                                                    boolean withRangeMerger)
     {
-        CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlans = new ReplicaPlanIterator(keyRange, null, keyspace, ConsistencyLevel.ONE);
+        CloseableIterator<ReplicaPlan.ForRangeRead> replicaPlans = new ReplicaPlanIterator(keyRange, null, keyspace, ConsistencyLevel.ONE, false);
         if (withRangeMerger)
             replicaPlans = new ReplicaPlanMerger(replicaPlans, keyspace, ConsistencyLevel.ONE);
 
diff --git a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java
index f64e446e32b8..9c3025412d3a 100644
--- a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java
+++ b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java
@@ -38,7 +38,6 @@
 import org.apache.cassandra.exceptions.ConfigurationException;
 import org.apache.cassandra.index.StubIndex;
 import org.apache.cassandra.schema.IndexMetadata;
-import org.apache.cassandra.service.QueryInfoTracker;
 
 import static org.apache.cassandra.db.ConsistencyLevel.ONE;
 import static org.apache.cassandra.service.QueryInfoTracker.*;
@@ -77,7 +76,7 @@ public void tesConcurrencyFactor()
         // verify that a low concurrency factor is not capped by the max concurrency factor
         PartitionRangeReadCommand command = command(cfs, 50, 50);
         try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime(), ReadTracker.NOOP);
-             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE))
+             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE, command.rowFilter().allowFiltering))
         {
             assertEquals(2, partitions.concurrencyFactor());
             assertEquals(MAX_CONCURRENCY_FACTOR, partitions.maxConcurrencyFactor());
@@ -87,7 +86,7 @@ public void tesConcurrencyFactor()
         // verify that a high concurrency factor is capped by the max concurrency factor
         command = command(cfs, 1000, 50);
         try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime(), ReadTracker.NOOP);
-             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE))
+             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE, command.rowFilter().allowFiltering))
         {
             assertEquals(MAX_CONCURRENCY_FACTOR, partitions.concurrencyFactor());
             assertEquals(MAX_CONCURRENCY_FACTOR, partitions.maxConcurrencyFactor());
@@ -97,7 +96,7 @@ public void tesConcurrencyFactor()
         // with 0 estimated results per range the concurrency factor should be 1
         command = command(cfs, 1000, 0);
         try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime(), ReadTracker.NOOP);
-             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE))
+             ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), command.indexQueryPlan(), keyspace, ONE, command.rowFilter().allowFiltering))
         {
             assertEquals(1, partitions.concurrencyFactor());
             assertEquals(MAX_CONCURRENCY_FACTOR, partitions.maxConcurrencyFactor());
diff --git a/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanIteratorTest.java b/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanIteratorTest.java
index 84f3a5e2e750..ea278328c19a 100644
--- a/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanIteratorTest.java
+++ b/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanIteratorTest.java
@@ -163,7 +163,7 @@ private final void testRanges(AbstractBounds<PartitionPosition> queryRange, Abst
     @SafeVarargs
     private final void testRanges(Keyspace keyspace, AbstractBounds<PartitionPosition> queryRange, AbstractBounds<PartitionPosition>... expected)
     {
-        try (ReplicaPlanIterator iterator = new ReplicaPlanIterator(queryRange, null, keyspace, ConsistencyLevel.ANY))
+        try (ReplicaPlanIterator iterator = new ReplicaPlanIterator(queryRange, null, keyspace, ConsistencyLevel.ANY, false))
         {
             List<AbstractBounds<PartitionPosition>> restrictedRanges = new ArrayList<>(expected.length);
             while (iterator.hasNext())
diff --git a/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanMergerTest.java b/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanMergerTest.java
index b577678c3ba0..fce5b7d0a850 100644
--- a/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanMergerTest.java
+++ b/test/unit/org/apache/cassandra/service/reads/range/ReplicaPlanMergerTest.java
@@ -392,7 +392,7 @@ private final void testRanges(ConsistencyLevel consistencyLevel,
                                   AbstractBounds<PartitionPosition> queryRange,
                                   AbstractBounds<PartitionPosition>... expected)
     {
-        try (ReplicaPlanIterator originals = new ReplicaPlanIterator(queryRange, null, keyspace, ANY); // ANY avoids endpoint erros
+        try (ReplicaPlanIterator originals = new ReplicaPlanIterator(queryRange, null, keyspace, ANY, false); // ANY avoids endpoint erros
              ReplicaPlanMerger merger = new ReplicaPlanMerger(originals, keyspace, consistencyLevel))
         {
             // collect the merged ranges