@@ -68,6 +68,14 @@ registry:
 | `path` | string | — | Connection string or file path |
 | `schema_mode` | string | `auto` | SQL registry only. `auto`: create tables on startup; `verify`: check tables exist, error if missing; `skip`: no DDL or verification. See [SQL Registry docs](registries/sql.md#schema-management-schema_mode). |
 | `mcp.enabled` | bool | `false` | Enable MCP (Model Context Protocol) on the REST registry server |
+| `serve_features_while_materializing` | bool | `false` | Keep serving a feature view's last-materialized values while it is in the `MATERIALIZING` state, instead of rejecting online requests during materialization |
+
+When `serve_features_while_materializing` is `true`, online serving continues for a
+feature view while `feast materialize` runs against a shared registry (which
+transitions the feature view to `MATERIALIZING`). This avoids serving interruptions
+from routine incremental materialization; feature views serve their
+last-materialized values until materialization completes. States that never had
+online data (e.g. `CREATED`, `GENERATED`) remain gated.
 
 When `registry.mcp.enabled` is `true`, the REST registry server exposes registry
 metadata (entities, feature views, feature services) as MCP tool endpoints for
 
@@ -65,6 +65,11 @@ class BaseRegistry(ABC):
     feature views, and data sources).
     """
 
+    # Opt-in: keep serving a feature view's last-materialized values while it is
+    # MATERIALIZING. Registries built from a RegistryConfig set it from
+    # ``registry_config.serve_features_while_materializing``.
+    serve_features_while_materializing: bool = False
+
     # Entity operations
     @abstractmethod
     def apply_entity(self, entity: Entity, project: str, commit: bool = True):
 
@@ -247,6 +247,12 @@ def __init__(
             else False
         )
 
+        self.serve_features_while_materializing = (
+            registry_config.serve_features_while_materializing
+            if registry_config is not None
+            else False
+        )
+
         self.cache_mode = (
             registry_config.cache_mode if registry_config is not None else "sync"
         )
 
@@ -104,6 +104,9 @@ def __init__(
     ):
         self.auth_config = auth_config
         assert isinstance(registry_config, RemoteRegistryConfig)
+        self.serve_features_while_materializing = (
+            registry_config.serve_features_while_materializing
+        )
         self.channel = self._create_grpc_channel(registry_config)
         weakref.finalize(self, self.channel.close)
 
 
@@ -149,6 +149,9 @@ def __init__(
                     execute_snowflake_statement(conn, query)
 
         self.purge_feast_metadata = registry_config.purge_feast_metadata
+        self.serve_features_while_materializing = (
+            registry_config.serve_features_while_materializing
+        )
         self.project = project
 
         # Initialize cache state before any method that may trigger
 
@@ -376,6 +376,9 @@ def __init__(
         self.enable_online_versioning = (
             registry_config.enable_online_feature_view_versioning
         )
+        self.serve_features_while_materializing = (
+            registry_config.serve_features_while_materializing
+        )
         super().__init__(
             project=project,
             cache_ttl_seconds=registry_config.cache_ttl_seconds,
 
@@ -206,6 +206,15 @@ class RegistryConfig(FeastBaseModel):
         history tracking in the registry is always active regardless of this
         setting. """
 
+    serve_features_while_materializing: StrictBool = False
+    """ bool: Allow online serving to continue for a feature view while it is in
+        the ``MATERIALIZING`` state. When ``feature_store.materialize()`` runs against
+        a shared registry it transitions the feature view to ``MATERIALIZING`` and
+        commits that state, which otherwise causes concurrent feature servers to
+        reject requests until materialization completes. When True, feature views in
+        the ``MATERIALIZING`` state keep serving their last-materialized values.
+        Truly-unavailable states (e.g. ``CREATED``, ``GENERATED``) remain gated. """
+
     mcp: Optional[McpRegistryConfig] = None
     """ McpRegistryConfig: MCP (Model Context Protocol) configuration for the registry REST server. """
 
@@ -238,6 +247,30 @@ def validate_path(cls, path: str, values: ValidationInfo) -> str:
             return cls._normalize_postgres_scheme(path, "path")
         return path
 
+    @model_validator(mode="after")
+    def _warn_on_unsafe_serve_while_materializing(self) -> "RegistryConfig":
+        """Warn when ``serve_features_while_materializing`` is combined with a
+        registry configuration where it is a no-op or where its guarantees may
+        not hold. These are advisory warnings only, never hard failures.
+        """
+        if self.serve_features_while_materializing:
+            if self.registry_type != "sql":
+                _logger.warning(
+                    "`serve_features_while_materializing` is enabled but "
+                    f"`registry_type` is '{self.registry_type}'. The flag targets "
+                    "the serving interruption caused by concurrent servers sharing "
+                    "a `sql` registry that materialization flips to `MATERIALIZING`; "
+                    "on other registry types it typically has no effect."
+                )
+            if self.cache_mode == "thread":
+                _logger.warning(
+                    "`serve_features_while_materializing` is enabled together with "
+                    "`cache_mode='thread'`. In thread mode the registry cache may lag "
+                    "by up to `cache_ttl_seconds`, so feature-view state transitions "
+                    "(including the exit from `MATERIALIZING`) may be observed stale."
+                )
+        return self
+
 
 class MaterializationConfig(BaseModel):
     """Configuration options for feature materialization behavior."""
 
@@ -1430,9 +1430,20 @@ def _append_or_merge_source_fv(fv_with_projection: "FeatureView") -> None:
         if hasattr(fv, "state"):
             from feast.feature_view import FeatureViewState
 
-            if isinstance(fv.state, FeatureViewState) and fv.state not in (
+            servable_states = {
                 FeatureViewState.STATE_UNSPECIFIED,
                 FeatureViewState.AVAILABLE_ONLINE,
+            }
+            # When 'serve_features_while_materializing' is enabled, keep serving
+            # the last-materialized values while a feature view is MATERIALIZING,
+            # so routine incremental materialization against a shared registry does
+            # not interrupt concurrent feature servers (see issue #6780).
+            if getattr(registry, "serve_features_while_materializing", False):
+                servable_states.add(FeatureViewState.MATERIALIZING)
+
+            if (
+                isinstance(fv.state, FeatureViewState)
+                and fv.state not in servable_states
             ):
                 raise ValueError(
                     f"Feature view '{name}' is in state '{fv.state.name}' "
 
@@ -4,6 +4,7 @@
 
 import pytest
 
+from feast import utils
 from feast.data_format import AvroFormat, ParquetFormat
 from feast.data_source import KafkaSource
 from feast.entity import Entity
@@ -431,3 +432,74 @@ def test_materialize_disabled_fv_by_name_raises(self, local_feature_store):
                 end_date=datetime.utcnow(),
             )
         store.teardown()
+
+
+# ---------------------------------------------------------------------------
+# Serving lifecycle gate: serve_features_while_materializing
+# ---------------------------------------------------------------------------
+
+
+class _StubRegistry:
+    """Minimal registry stub exposing what _get_feature_views_to_use needs."""
+
+    def __init__(self, fv, serve_features_while_materializing=False):
+        self._fv = fv
+        self.serve_features_while_materializing = serve_features_while_materializing
+
+    def get_any_feature_view(self, name, project, allow_cache=False):
+        return self._fv
+
+
+class TestServeWhileMaterializingGate:
+    def _fv_in_state(self, state):
+        fv = _simple_feature_view()
+        fv.state = state
+        return fv
+
+    def test_materializing_blocked_by_default(self):
+        registry = _StubRegistry(self._fv_in_state(FeatureViewState.MATERIALIZING))
+        with pytest.raises(ValueError, match="cannot serve features"):
+            utils._get_feature_views_to_use(registry, "default", ["test_fv:f1"])
+
+    def test_materializing_served_when_flag_enabled(self):
+        registry = _StubRegistry(
+            self._fv_in_state(FeatureViewState.MATERIALIZING),
+            serve_features_while_materializing=True,
+        )
+        fvs, _ = utils._get_feature_views_to_use(registry, "default", ["test_fv:f1"])
+        assert [fv.name for fv in fvs] == ["test_fv"]
+
+    def test_available_online_served_regardless_of_flag(self):
+        registry = _StubRegistry(self._fv_in_state(FeatureViewState.AVAILABLE_ONLINE))
+        fvs, _ = utils._get_feature_views_to_use(registry, "default", ["test_fv:f1"])
+        assert [fv.name for fv in fvs] == ["test_fv"]
+
+    def test_created_still_blocked_even_with_flag(self):
+        registry = _StubRegistry(
+            self._fv_in_state(FeatureViewState.CREATED),
+            serve_features_while_materializing=True,
+        )
+        with pytest.raises(ValueError, match="cannot serve features"):
+            utils._get_feature_views_to_use(registry, "default", ["test_fv:f1"])
+
+
+class TestServeWhileMaterializingRegistryPropagation:
+    def test_base_registry_defaults_to_false(self):
+        from feast.infra.registry.base_registry import BaseRegistry
+
+        assert BaseRegistry.serve_features_while_materializing is False
+
+    @pytest.mark.parametrize("enabled", [True, False])
+    def test_remote_registry_reads_flag_from_config(self, enabled):
+        from feast.infra.registry.remote import RemoteRegistry, RemoteRegistryConfig
+
+        config = RemoteRegistryConfig(
+            registry_type="remote",
+            path="localhost:6570",
+            serve_features_while_materializing=enabled,
+        )
+        registry = RemoteRegistry(config, project="test", repo_path=None)
+        try:
+            assert registry.serve_features_while_materializing is enabled
+        finally:
+            registry.close()
@@ -196,8 +196,11 @@ def tracking_import(name, *args, **kwargs):
             capture_output=True,
             text=True,
             env=env,
-            # Cold imports can be slow on macOS under parallel test load.
-            timeout=180,
+            # A cold subprocess importing feast.offline_server pulls in pyarrow and
+            # gRPC, which can take well over a minute on contended CI runners
+            # (notably macOS). Allow generous headroom so this does not flake while
+            # still catching a genuine import hang.
+            timeout=300,
         )
     except subprocess.TimeoutExpired as exc:
         # TimeoutExpired captures bytes even when subprocess.run uses text=True.
Original file line number	Diff line number	Diff line change
`@@ -247,6 +247,12 @@ def __init__(`
`247`	`247`	`else False`
`248`	`248`	`)`
`249`	`249`
	`250`	`+ self.serve_features_while_materializing = (`
	`251`	`+ registry_config.serve_features_while_materializing`
	`252`	`+ if registry_config is not None`
	`253`	`+ else False`
	`254`	`+ )`
	`255`	`+`
`250`	`256`	`self.cache_mode = (`
`251`	`257`	`registry_config.cache_mode if registry_config is not None else "sync"`
`252`	`258`	`)`