@@ -2165,13 +2165,15 @@ def fill_config_defaults(cls, serialized_obj: dict[str, Any]) -> None:
                 dag[key] = get(section, option)
 
     @classmethod
-    def validate_serialized_dag(cls, serialized_obj: dict[str, Any]) -> None:
+    def validate_serialized_dag(cls, serialized_obj: dict[str, Any]) -> SerializedDAG:
         """
         Check that a serialized Dag, such as one a Lang-SDK runtime produced, can be stored and loaded.
 
-        It must match the JSON schema, have unique task ids, deserialize, and have no cycle in its task graph.
-        *serialized_obj* is not changed.
+        It must match the JSON schema, have unique task ids and deserialize. Like a Dag built with the SDK,
+        it must not set a ``max_active_runs`` its timetable forbids, nor ``catchup`` without a
+        ``start_date``, and its task graph must have no cycle. *serialized_obj* is not changed.
 
+        :return: The deserialized Dag.
         :raises DeserializationError: if it does not.
         """
         dag = serialized_obj.get("dag")
@@ -2190,18 +2192,30 @@ def validate_serialized_dag(cls, serialized_obj: dict[str, Any]) -> None:
                 dag_id, f"Dag {dag_id!r} has more than one task with id {', '.join(map(repr, duplicates))}"
             )
         try:
-            cls.from_dict(copy.deepcopy(serialized_obj))
+            deserialized = cls.from_dict(copy.deepcopy(serialized_obj))
         except Exception as e:
             cause = e.__cause__ if isinstance(e, DeserializationError) and e.__cause__ else e
             raise DeserializationError(
                 dag_id, f"Dag {dag_id!r} cannot be deserialized: {type(cause).__name__}: {cause}"
             ) from e
-        downstream = {
-            task[Encoding.VAR]["task_id"]: task[Encoding.VAR].get("downstream_task_ids") or ()
-            for task in serialized_obj["dag"]["tasks"]
-        }
+        if (
+            limit := deserialized.timetable.active_runs_limit
+        ) is not None and deserialized.max_active_runs > limit:
+            raise DeserializationError(
+                dag_id,
+                f"Dag {dag_id!r} sets max_active_runs {deserialized.max_active_runs}, "
+                f"but {type(deserialized.timetable).__name__} allows at most {limit}",
+            )
+        if (
+            deserialized.catchup
+            and deserialized.timetable.can_be_scheduled
+            and not (deserialized.start_date or "start_date" in deserialized.default_args)
+        ):
+            raise DeserializationError(dag_id, f"Dag {dag_id!r} sets catchup but no start_date")
+        downstream = {task_id: task.downstream_task_ids for task_id, task in deserialized.task_dict.items()}
         if (task_id := detect_cycle(downstream, downstream.__getitem__)) is not None:
             raise DeserializationError(dag_id, f"Dag {dag_id!r} has a cycle through task {task_id!r}")
+        return deserialized
 
 
 class TaskGroupSerialization(BaseSerialization):
 
@@ -5196,13 +5196,36 @@ def test_rejects_a_dag_that_does_not_load(self, change, error):
         with pytest.raises(DeserializationError, match=f"^{re.escape(error)}"):
             DagSerialization.validate_serialized_dag(data)
 
-    def test_rejects_a_task_entry_that_is_not_an_operator(self):
+    def test_returns_the_deserialized_dag(self):
+        dag = DagSerialization.validate_serialized_dag(self._serialize())
+
+        assert isinstance(dag, SerializedDAG)
+        assert dag.dag_id == "checked_dag"
+        assert dag.task_dict["extract"].downstream_task_ids == {"load"}
+
+    @pytest.mark.parametrize(
+        ("entry", "json_path"),
+        [
+            pytest.param({}, "$.dag.tasks[2]", id="empty"),
+            pytest.param("x", "$.dag.tasks[2]", id="not-an-object"),
+            pytest.param(
+                {"__type": "dag", "__var": {"task_id": "t"}}, "$.dag.tasks[2]['__type']", id="wrong-type"
+            ),
+            pytest.param({"__type": "operator", "__var": {}}, "$.dag.tasks[2]['__var']", id="no-task-id"),
+            pytest.param(
+                {"__type": "operator", "__var": {"task_id": 5}},
+                "$.dag.tasks[2]['__var'].task_id",
+                id="task-id-not-a-string",
+            ),
+        ],
+    )
+    def test_rejects_a_task_entry_that_is_not_an_operator(self, entry, json_path):
         data = self._serialize()
-        data["dag"]["tasks"].append({})
+        data["dag"]["tasks"].append(entry)
 
         with pytest.raises(
             DeserializationError,
-            match=r"^Dag 'checked_dag' does not match the schema at \$\.dag\.tasks\[2\]: ",
+            match=rf"^Dag 'checked_dag' does not match the schema at {re.escape(json_path)}: ",
         ):
             DagSerialization.validate_serialized_dag(data)
 
@@ -5232,6 +5255,62 @@ def test_rejects_a_dag_with_a_cycle(self):
         with pytest.raises(DeserializationError, match="^Dag 'checked_dag' has a cycle through task 'load'$"):
             DagSerialization.validate_serialized_dag(data)
 
+    def test_rejects_a_cycle_in_the_legacy_downstream_key(self):
+        data = self._serialize()
+        load = next(task for task in data["dag"]["tasks"] if task["__var"]["task_id"] == "load")
+        load["__var"]["_downstream_task_ids"] = ["extract"]
+
+        with pytest.raises(DeserializationError, match="^Dag 'checked_dag' has a cycle through task 'load'$"):
+            DagSerialization.validate_serialized_dag(data)
+
+    @pytest.mark.parametrize(
+        ("change", "error"),
+        [
+            pytest.param(
+                {},
+                "Dag 'checked_dag' sets max_active_runs 16, but ContinuousTimetable allows at most 1",
+                id="unset",
+            ),
+            pytest.param(
+                {"max_active_runs": 2},
+                "Dag 'checked_dag' sets max_active_runs 2, but ContinuousTimetable allows at most 1",
+                id="above-the-limit",
+            ),
+        ],
+    )
+    def test_rejects_max_active_runs_above_the_timetable_limit(self, change, error):
+        data = DagSerialization.to_dict(DAG(dag_id="checked_dag", schedule="@continuous", max_active_runs=1))
+        del data["dag"]["max_active_runs"]
+        data["dag"].update(change)
+
+        with pytest.raises(DeserializationError, match=f"^{re.escape(error)}$"):
+            DagSerialization.validate_serialized_dag(data)
+
+    def test_rejects_catchup_without_a_start_date(self):
+        data = DagSerialization.to_dict(DAG(dag_id="checked_dag", schedule="@daily"))
+        data["dag"]["catchup"] = True
+
+        with pytest.raises(DeserializationError, match="^Dag 'checked_dag' sets catchup but no start_date$"):
+            DagSerialization.validate_serialized_dag(data)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            pytest.param(
+                {
+                    "schedule": "@daily",
+                    "default_args": {"start_date": datetime(2024, 1, 1, tzinfo=dt_timezone.utc)},
+                },
+                id="start-date-in-default-args",
+            ),
+            pytest.param({"schedule": None}, id="unscheduled"),
+        ],
+    )
+    def test_accepts_catchup_the_sdk_dag_accepts(self, kwargs):
+        dag = DAG(dag_id="checked_dag", catchup=True, **kwargs)
+
+        assert DagSerialization.validate_serialized_dag(DagSerialization.to_dict(dag)).catchup is True
+
 
 class TestFillConfigDefaults:
     CONFIG = {