diff --git a/source/blender/blenkernel/BKE_node_tree_zones.hh b/source/blender/blenkernel/BKE_node_tree_zones.hh
index 57657dde24d..dc8d1121ee6 100644
--- a/source/blender/blenkernel/BKE_node_tree_zones.hh
+++ b/source/blender/blenkernel/BKE_node_tree_zones.hh
@@ -12,6 +12,7 @@
 
 #include "DNA_node_types.h"
 
+#include "BLI_map.hh"
 #include "BLI_vector.hh"
 
 namespace blender::bke {
@@ -50,7 +51,9 @@ class bNodeTreeZone {
 
 class bNodeTreeZones {
  public:
-  Vector<std::unique_ptr<bNodeTreeZone>> zones;
+  Vector<std::unique_ptr<bNodeTreeZone>> zones_ptrs;
+  /** Same as #zones_ptrs, but usually easier to iterate over. */
+  Vector<bNodeTreeZone *> zones;
   Vector<bNodeTreeZone *> root_zones;
   Vector<const bNode *> nodes_outside_zones;
   /**
diff --git a/source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc b/source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc
index 34d8f7170e7..51466ddc5ae 100644
--- a/source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc
+++ b/source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc
@@ -258,14 +258,14 @@ static AnonymousAttributeInferencingResult analyze_anonymous_attribute_usages(
   const bNodeTreeZones *zones = tree.zones();
   Vector<const bNodeTreeZone *> repeat_zones_to_consider;
   if (zones) {
-    for (const std::unique_ptr<bNodeTreeZone> &zone : zones->zones) {
+    for (const bNodeTreeZone *zone : zones->zones) {
       if (ELEM(nullptr, zone->input_node, zone->output_node)) {
         continue;
       }
       if (zone->output_node->type != GEO_NODE_REPEAT_OUTPUT) {
         continue;
       }
-      repeat_zones_to_consider.append(zone.get());
+      repeat_zones_to_consider.append(zone);
     }
   }
 
diff --git a/source/blender/blenkernel/intern/node_tree_zones.cc b/source/blender/blenkernel/intern/node_tree_zones.cc
index 388c74c5c12..5269d7f92ec 100644
--- a/source/blender/blenkernel/intern/node_tree_zones.cc
+++ b/source/blender/blenkernel/intern/node_tree_zones.cc
@@ -74,13 +74,12 @@ struct ZoneRelation {
 };
 
 static std::optional<Vector<ZoneRelation>> get_direct_zone_relations(
-    const Span<std::unique_ptr<bNodeTreeZone>> all_zones,
-    const BitGroupVector<> &depend_on_input_flag_array)
+    const Span<bNodeTreeZone *> all_zones, const BitGroupVector<> &depend_on_input_flag_array)
 {
   VectorSet<ZoneRelation> all_zone_relations;
 
   /* Gather all relations, even the transitive once. */
-  for (const std::unique_ptr<bNodeTreeZone> &zone : all_zones) {
+  for (bNodeTreeZone *zone : all_zones) {
     const int zone_i = zone->index;
     for (const bNode *node : {zone->output_node}) {
       if (node == nullptr) {
@@ -89,7 +88,7 @@ static std::optional<Vector<ZoneRelation>> get_direct_zone_relations(
       const BoundedBitSpan depend_on_input_flags = depend_on_input_flag_array[node->index()];
       bits::foreach_1_index(depend_on_input_flags, [&](const int parent_zone_i) {
         if (parent_zone_i != zone_i) {
-          all_zone_relations.add_new({all_zones[parent_zone_i].get(), zone.get()});
+          all_zone_relations.add_new({all_zones[parent_zone_i], zone});
         }
       });
     }
@@ -133,7 +132,7 @@ static std::optional<Vector<ZoneRelation>> get_direct_zone_relations(
 }
 
 static bool update_zone_per_node(const Span<const bNode *> all_nodes,
-                                 const Span<std::unique_ptr<bNodeTreeZone>> all_zones,
+                                 const Span<bNodeTreeZone *> all_zones,
                                  const BitGroupVector<> &depend_on_input_flag_array,
                                  const Map<const bNode *, bNodeTreeZone *> &zone_by_inout_node,
                                  Map<int, int> &r_zone_by_node_id,
@@ -145,7 +144,7 @@ static bool update_zone_per_node(const Span<const bNode *> all_nodes,
     const BoundedBitSpan depend_on_input_flags = depend_on_input_flag_array[node_i];
     bNodeTreeZone *parent_zone = nullptr;
     bits::foreach_1_index(depend_on_input_flags, [&](const int parent_zone_i) {
-      bNodeTreeZone *zone = all_zones[parent_zone_i].get();
+      bNodeTreeZone *zone = all_zones[parent_zone_i];
       if (ELEM(&node, zone->input_node, zone->output_node)) {
         return;
       }
@@ -228,7 +227,10 @@ static std::unique_ptr<bNodeTreeZones> discover_tree_zones(const bNodeTree &tree
 
   const Span<const bNode *> all_nodes = tree.all_nodes();
   Map<const bNode *, bNodeTreeZone *> zone_by_inout_node;
-  tree_zones->zones = find_zone_nodes(tree, *tree_zones, zone_by_inout_node);
+  tree_zones->zones_ptrs = find_zone_nodes(tree, *tree_zones, zone_by_inout_node);
+  for (const std::unique_ptr<bNodeTreeZone> &zone : tree_zones->zones_ptrs) {
+    tree_zones->zones.append(zone.get());
+  }
 
   const int zones_num = tree_zones->zones.size();
   const int nodes_num = all_nodes.size();
@@ -299,9 +301,9 @@ static std::unique_ptr<bNodeTreeZones> discover_tree_zones(const bNodeTree &tree
   }
 
   Set<const bNodeTreeZone *> found_zones;
-  for (std::unique_ptr<bNodeTreeZone> &main_zone : tree_zones->zones) {
+  for (bNodeTreeZone *main_zone : tree_zones->zones) {
     found_zones.clear();
-    for (bNodeTreeZone *zone = main_zone.get(); zone; zone = zone->parent_zone) {
+    for (bNodeTreeZone *zone = main_zone; zone; zone = zone->parent_zone) {
       if (!found_zones.add(zone)) {
         /* Found cyclic parent relationships between zones. */
         return {};
@@ -310,13 +312,13 @@ static std::unique_ptr<bNodeTreeZones> discover_tree_zones(const bNodeTree &tree
   }
 
   /* Update depths. */
-  for (std::unique_ptr<bNodeTreeZone> &zone : tree_zones->zones) {
+  for (bNodeTreeZone *zone : tree_zones->zones) {
     update_zone_depths(*zone);
   }
 
-  for (std::unique_ptr<bNodeTreeZone> &zone : tree_zones->zones) {
+  for (bNodeTreeZone *zone : tree_zones->zones) {
     if (zone->depth == 0) {
-      tree_zones->root_zones.append(zone.get());
+      tree_zones->root_zones.append(zone);
     }
   }
 
@@ -371,7 +373,7 @@ bool bNodeTreeZone::contains_node_recursively(const bNode &node) const
   if (zone_i == -1) {
     return false;
   }
-  for (const bNodeTreeZone *zone = zones->zones[zone_i].get(); zone; zone = zone->parent_zone) {
+  for (const bNodeTreeZone *zone = zones->zones[zone_i]; zone; zone = zone->parent_zone) {
     if (zone == this) {
       return true;
     }
@@ -415,7 +417,7 @@ const bNodeTreeZone *bNodeTreeZones::get_zone_by_node(const int32_t node_id) con
   if (zone_i == -1) {
     return nullptr;
   }
-  return this->zones[zone_i].get();
+  return this->zones[zone_i];
 }
 
 Vector<const bNodeTreeZone *> bNodeTreeZones::get_zone_stack_for_node(const int node_id) const
@@ -526,9 +528,9 @@ const bNodeZoneType *zone_type_by_node_type(const int node_type)
 
 std::ostream &operator<<(std::ostream &stream, const bNodeTreeZones &zones)
 {
-  for (const std::unique_ptr<bNodeTreeZone> &zone : zones.zones) {
+  for (const bNodeTreeZone *zone : zones.zones) {
     stream << *zone;
-    if (zones.zones.last().get() != zone.get()) {
+    if (zones.zones.last() != zone) {
       stream << "\n";
     }
   }
diff --git a/source/blender/editors/space_node/node_draw.cc b/source/blender/editors/space_node/node_draw.cc
index a55b08f0c7b..b3ace4d5a2e 100644
--- a/source/blender/editors/space_node/node_draw.cc
+++ b/source/blender/editors/space_node/node_draw.cc
@@ -4429,7 +4429,7 @@ static void add_rect_corner_positions(Vector<float2> &positions, const rctf &rec
 
 static void find_bounds_by_zone_recursive(const SpaceNode &snode,
                                           const bNodeTreeZone &zone,
-                                          const Span<std::unique_ptr<bNodeTreeZone>> all_zones,
+                                          const Span<const bNodeTreeZone *> all_zones,
                                           MutableSpan<Vector<float2>> r_bounds_by_zone)
 {
   const float node_padding = UI_UNIT_X;
@@ -4558,7 +4558,7 @@ static void node_draw_zones_and_frames(const bContext &C,
   using ZoneOrNode = std::variant<const bNodeTreeZone *, const bNode *>;
   Vector<ZoneOrNode> draw_order;
   for (const int zone_i : IndexRange(zones_num)) {
-    draw_order.append(zones->zones[zone_i].get());
+    draw_order.append(zones->zones[zone_i]);
   }
   for (const bNode *node : ntree.all_nodes()) {
     if (node->flag & NODE_BACKGROUND) {
diff --git a/source/blender/nodes/intern/geometry_nodes_lazy_function.cc b/source/blender/nodes/intern/geometry_nodes_lazy_function.cc
index c2784d12c7a..3d32ffadf2e 100644
--- a/source/blender/nodes/intern/geometry_nodes_lazy_function.cc
+++ b/source/blender/nodes/intern/geometry_nodes_lazy_function.cc
@@ -4183,7 +4183,7 @@ const GeometryNodesLazyFunctionGraphInfo *ensure_geometry_nodes_lazy_function_gr
   if (tree_zones == nullptr) {
     return nullptr;
   }
-  for (const std::unique_ptr<bNodeTreeZone> &zone : tree_zones->zones) {
+  for (const bNodeTreeZone *zone : tree_zones->zones) {
     if (zone->input_node == nullptr || zone->output_node == nullptr) {
       /* Simulations and repeats need input and output nodes. */
       return nullptr;