diff --git a/CMakeLists.txt b/CMakeLists.txt
index f2dcc98f82..0416c118cd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -394,6 +394,7 @@ include(${openPMD_SOURCE_DIR}/cmake/dependencies/pybind11.cmake)
 set(CORE_SOURCE
         src/config.cpp
         src/ChunkInfo.cpp
+        src/CustomHierarchy.cpp
         src/Dataset.cpp
         src/Datatype.cpp
         src/Error.cpp
@@ -426,6 +427,11 @@ set(CORE_SOURCE
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp
         src/backend/Writable.cpp
+        src/backend/scientific_defaults/ScientificDefaults.cpp
+        src/backend/scientific_defaults/ScientificDefaults_auxiliary.cpp
+        src/backend/scientific_defaults/ProcessParsedAttribute.cpp
+        src/backend/scientific_defaults/AttributeReader.cpp
+        src/backend/scientific_defaults/ConfigAttribute.cpp
         src/auxiliary/OneDimensionalBlockSlicer.cpp
         src/helper/list_series.cpp
         src/snapshots/ContainerImpls.cpp
@@ -827,6 +833,7 @@ if(openPMD_BUILD_TESTING)
             list(APPEND ${out_list}
                 test/Files_Core/automatic_variable_encoding.cpp
                 test/Files_Core/read_nonexistent_attribute.cpp
+                test/Files_Core/custom_hierarchy.cpp
             )
         endif()
     endmacro()
diff --git a/examples/10_streaming_write.cpp b/examples/10_streaming_write.cpp
index 01bd2fcb33..e38ab3daa9 100644
--- a/examples/10_streaming_write.cpp
+++ b/examples/10_streaming_write.cpp
@@ -82,6 +82,8 @@ int main()
             pos.resetDataset(dataset);
             pos.storeChunk(local_data, Offset{0}, global_extent);
         }
+        auto ch = iteration.customHierarchies();
+        ch["rabimmel"].setAttribute("rabammel", "rabumm");
         iteration.close();
     }
 
diff --git a/examples/2_read_serial.cpp b/examples/2_read_serial.cpp
index 4eaac05ea2..2a0826a5eb 100644
--- a/examples/2_read_serial.cpp
+++ b/examples/2_read_serial.cpp
@@ -31,7 +31,8 @@ using namespace openPMD;
 int main()
 {
     Series series = Series(
-        "../samples/git-sample/data%T.h5",
+        // "../samples/git-sample/data%T.h5",
+        "data.h5",
         Access::READ_ONLY,
         R"({"defer_iteration_parsing": true})");
     cout << "Read a Series with openPMD standard version " << series.openPMD()
@@ -99,9 +100,24 @@ int main()
 
     auto all_data = E_x.loadChunk<double>();
 
+    auto ch = series.customHierarchies();
+    ch.printRecursively();
+    std::cout << "READING 200/fields" << std::endl;
+    ch["data"]["200"]["fields"].read();
+    std::cout << "READING 200/particles" << std::endl;
+    ch["data"]["200"]["particles"].read();
+    std::cout << "READING 300" << std::endl;
+    ch["data"]["300"].read(0);
+    ch.printRecursively();
+
     // The iteration can be closed in order to help free up resources.
     // The iteration's content will be flushed automatically.
     i.close();
+    std::cout << "OPENING 200" << std::endl;
+    i = series.snapshots()[200].open();
+    ch.printRecursively();
+    series.snapshots()[300].open();
+
     cout << "Full E/x starts with:\n\t{";
     for (size_t col = 0; col < extent[1] && col < 5; ++col)
         cout << all_data.get()[col] << ", ";
diff --git a/include/openPMD/CustomHierarchy.hpp b/include/openPMD/CustomHierarchy.hpp
new file mode 100644
index 0000000000..f29ffa5738
--- /dev/null
+++ b/include/openPMD/CustomHierarchy.hpp
@@ -0,0 +1,206 @@
+/* Copyright 2023 Franz Poeschel
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/RecordComponent.hpp"
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/Container.hpp"
+
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace openPMD
+{
+class CustomHierarchy;
+namespace internal
+{
+    using CustomHierarchyData = ContainerData<Attributable>;
+} // namespace internal
+
+class CustomHierarchy;
+
+/*
+ * This is its own class, so the return value of asContainerOf() is also
+ * convsersible again.
+ */
+template <typename MappedType>
+class ConvertibleContainer : public Container<MappedType>
+{
+    template <typename>
+    friend class ConversibleContainer;
+    friend class CustomHierarchy;
+
+protected:
+    using Container_t = Container<MappedType>;
+    using Data_t = internal::ContainerData<MappedType>;
+    static_assert(
+        std::is_base_of_v<typename Container_t::ContainerData, Data_t>);
+
+    using Container_t::Container_t;
+
+private:
+    explicit ConvertibleContainer() = default;
+
+public:
+    template <typename TargetType>
+    auto asContainerOf() -> ConvertibleContainer<TargetType>
+    {
+        if constexpr (
+            std::is_same_v<TargetType, CustomHierarchy> ||
+            std::is_same_v<TargetType, Mesh> ||
+            std::is_same_v<TargetType, ParticleSpecies> ||
+            std::is_same_v<TargetType, RecordComponent>)
+        {
+            // TODO: If Mesh or ParticleSpecies, create Container on the fly by
+            // evaluating the meshes/particles path. If RecordComponent, maybe
+            // use dynamic casting to check if children are datasets?
+            throw std::runtime_error("UNIMPLEMENTED");
+        }
+        else
+        {
+            static_assert(
+                auxiliary::dependent_false_v<TargetType>,
+                "[CustomHierarchy::asContainerOf] Type parameter must be "
+                "one of: CustomHierarchy, RecordComponent, Mesh, "
+                "ParticleSpecies.");
+        }
+    }
+};
+
+namespace traits
+{
+    template <>
+    struct DeferredInitPolicy<Container<CustomHierarchy>>
+    {
+        template <typename Container_const_or_not>
+        static void call(Container_const_or_not &);
+    };
+
+    template <>
+    struct GenerationPolicy<CustomHierarchy>
+    {
+        constexpr static bool is_noop = false;
+        template <typename Container, typename Iterator>
+        void operator()(Container &cont, Iterator &it)
+        {
+            auto &writable = it->second.writable();
+
+            // These should be different
+            auto child_shared_data = &it->second.Attributable::get();
+            auto parent_shared_data = &cont.Attributable::get();
+            if (child_shared_data == parent_shared_data)
+            {
+                throw std::runtime_error(
+                    "Trying to emplace object as its own child");
+            }
+
+            // These might be different, but might also be the same
+            //
+            // For an explanation, ref. the documentation of
+            // Writable::attributable: This is a pointer back to the first
+            // created Attributable instance linking this Writable. There might
+            // be multiple Attributable objects linking the same backend
+            // Writable object when opening multiple "views" on the same backend
+            // object, e.g. when a scalar Record is at the same time a
+            // RecordComponent, or when reopening an object as a
+            // CustomHierarchy.
+            //
+            // Since CustomHierarchy performs no memory management by default,
+            // we must ensure that the backpointer in Writable::attributable
+            // remains valid when the frontend instance pointed by
+            // Writable::attributable *is* the CustomHierarchy instance (happens
+            // when it is the first frontend object created for that backend
+            // object).
+            auto backpointer = writable.attributable;
+            auto emplaced_pointer = it->second.m_attri.get();
+            if (backpointer == emplaced_pointer)
+            {
+                (**cont.m_attri)
+                    .m_children_managed_as_custom_hierarchy[it->first] =
+                    it->second;
+            }
+        }
+    };
+} // namespace traits
+
+// TODO: Use Container<Attributable> internally, but otherwise override members
+// such that we have:
+//
+// operator[](key) -> CustomHierarchy
+//
+// Or find a better solution for having this automatically..
+class CustomHierarchy : public ConvertibleContainer<CustomHierarchy>
+{
+    friend class Iteration;
+    friend class Container<CustomHierarchy>;
+    friend class Attributable;
+    friend struct traits::DeferredInitPolicy<Container<CustomHierarchy>>;
+
+private:
+    using Parent_t = ConvertibleContainer<CustomHierarchy>;
+    using Container_t = typename Parent_t::Container_t;
+    using Data_t = typename Parent_t::Data_t;
+
+protected:
+    CustomHierarchy(NoInit);
+    CustomHierarchy(std::shared_ptr<internal::SharedAttributableData> other);
+    CustomHierarchy(Attributable const &other);
+
+    void read(std::vector<std::string> &currentPath);
+
+    void flush_internal(
+        internal::FlushParams const &, std::vector<std::string> currentPath);
+    void flush(std::string const &path, internal::FlushParams const &) override;
+
+    /**
+     * @brief Link with parent.
+     *
+     * @param w The Writable representing the parent.
+     */
+    void linkHierarchy(Writable &w) override;
+
+public:
+    CustomHierarchy();
+
+    CustomHierarchy(CustomHierarchy const &other) = default;
+    CustomHierarchy(CustomHierarchy &&other) = default;
+
+    CustomHierarchy &operator=(CustomHierarchy const &) = default;
+    CustomHierarchy &operator=(CustomHierarchy &&) = default;
+
+    // TODO maybe make this automatic somehow
+    // set max_recursion_depth = 0 for infinite cycling
+    // recursion depth includes the current object
+    // recursion will not continue expanding into regions that are already known
+    // (hence not transitively expand into unknown subregions of known regions)
+    void read(size_t max_recursion_depth = 1);
+
+    void printRecursively();
+
+private:
+    void printRecursively(std::string indent);
+};
+} // namespace openPMD
diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp
index 9b7735b5ba..b54b661c78 100644
--- a/include/openPMD/IO/AbstractIOHandler.hpp
+++ b/include/openPMD/IO/AbstractIOHandler.hpp
@@ -26,6 +26,7 @@
 #include "openPMD/IterationEncoding.hpp"
 #include "openPMD/config.hpp"
 #include "openPMD/version.hpp"
+#include <ostream>
 
 #if openPMD_HAVE_MPI
 #include <mpi.h>
@@ -81,6 +82,66 @@ enum class FlushLevel
     CreateOrOpenFiles
 };
 
+std::ostream &operator<<(std::ostream &, FlushLevel);
+
+namespace flush_level
+{
+    inline constexpr auto global_flushpoint(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            return true;
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    // same as global_flushpoint for now, but we will soon introduce
+    // immediate_flush
+    inline constexpr auto write_datasets(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            return true;
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto write_attributes(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::InternalFlush:
+            return true;
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto flush_hierarchy(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+            return true;
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+} // namespace flush_level
+
 enum class OpenpmdStandard
 {
     v_1_0_0,
@@ -121,6 +182,7 @@ namespace internal
      * To be used for reading
      */
     FlushParams const defaultFlushParams{};
+    FlushParams const publicFlush{FlushLevel::UserFlush};
 
     struct ParsedFlushParams;
 
diff --git a/include/openPMD/IO/AbstractIOHandlerImpl.hpp b/include/openPMD/IO/AbstractIOHandlerImpl.hpp
index d45ce1bdcc..fdb8af3599 100644
--- a/include/openPMD/IO/AbstractIOHandlerImpl.hpp
+++ b/include/openPMD/IO/AbstractIOHandlerImpl.hpp
@@ -39,7 +39,7 @@ class AbstractIOHandlerImpl
 
     virtual ~AbstractIOHandlerImpl() = default;
 
-    std::future<void> flush();
+    std::future<void> flush(FlushLevel);
 
     /**
      * Close the file corresponding with the writable and release file handles.
diff --git a/include/openPMD/IO/IOTask.hpp b/include/openPMD/IO/IOTask.hpp
index 25e0d6ad54..a8efab571e 100644
--- a/include/openPMD/IO/IOTask.hpp
+++ b/include/openPMD/IO/IOTask.hpp
@@ -35,6 +35,7 @@
 #include <cstddef>
 #include <memory>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <utility>
 #include <variant>
@@ -89,6 +90,8 @@ OPENPMDAPI_EXPORT_ENUM_CLASS(Operation){
 }; // note: if you change the enum members here, please update
    // docs/source/dev/design.rst
 
+std::ostream &operator<<(std::ostream &os, Operation op);
+
 namespace internal
 {
     /*
diff --git a/include/openPMD/IO/JSON/JSONIOHandlerImpl.hpp b/include/openPMD/IO/JSON/JSONIOHandlerImpl.hpp
index 6df0c60ced..3e0758aee2 100644
--- a/include/openPMD/IO/JSON/JSONIOHandlerImpl.hpp
+++ b/include/openPMD/IO/JSON/JSONIOHandlerImpl.hpp
@@ -241,7 +241,7 @@ class JSONIOHandlerImpl : public AbstractIOHandlerImpl
 
     void touch(Writable *, Parameter<Operation::TOUCH> const &) override;
 
-    std::future<void> flush();
+    std::future<void> flush(internal::ParsedFlushParams &params);
 
 private:
 #if openPMD_HAVE_MPI
diff --git a/include/openPMD/Iteration.hpp b/include/openPMD/Iteration.hpp
index abce61eef7..ccaf21d1ae 100644
--- a/include/openPMD/Iteration.hpp
+++ b/include/openPMD/Iteration.hpp
@@ -27,6 +27,9 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
+#include "openPMD/backend/PerIterationData.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <cstdint>
 #include <deque>
@@ -120,14 +123,16 @@ namespace internal
          */
         bool allow_reopening_implicitly = false;
 
-        /**
-         * Whether a step is currently active for this iteration.
-         * Used for file-based iteration layout, see Series.hpp for
-         * group-based layout.
-         * Access via stepStatus() method to automatically select the correct
-         * one among both flags.
+        /*
+         * This stores data items that are:
+         *
+         * 1. global in group and variable encodings
+         * 2. per-iteration in file encoding
+         *
+         * The struct is stored as part of the Series and as part of each
+         * Iteration. Access must be distinguished by iteration encoding.
          */
-        StepStatus m_stepStatus = StepStatus::NoStep;
+        PerIterationData m_perIterationData;
 
         /**
          * Cached copy of the key under which this Iteration lives in
@@ -145,13 +150,28 @@ namespace internal
         std::optional<DeferredParseAccess> m_deferredParseAccess{};
     };
 } // namespace internal
+
+class Meshes : public Container<Mesh>
+{
+public:
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+};
+
+class Particles : public Container<ParticleSpecies>
+{
+public:
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+};
+
 /** @brief  Logical compilation of data from one snapshot (e.g. a single
  * simulation cycle).
  *
  * @see
  * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#required-attributes-for-the-basepath
  */
-class Iteration : public Attributable
+class Iteration
+    : public Attributable
+    , internal::ScientificDefaults
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -164,6 +184,8 @@ class Iteration : public Attributable
     friend class StatefulSnapshotsContainer;
     template <typename>
     friend struct traits::GenerationPolicy;
+    friend class internal::ScientificDefaults;
+    friend class Attributable;
 
 public:
     Iteration(Iteration const &) = default;
@@ -279,8 +301,10 @@ class Iteration : public Attributable
     [[deprecated("This attribute is no longer set by the openPMD-api.")]] bool
     closedByWriter() const;
 
-    Container<Mesh> meshes{};
-    Container<ParticleSpecies> particles{}; // particleSpecies?
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
+    Meshes meshes{};
+    Particles particles{};
 
     virtual ~Iteration() = default;
 
@@ -442,7 +466,7 @@ class Iteration : public Attributable
      *
      * @param w The Writable representing the parent.
      */
-    virtual void linkHierarchy(Writable &w);
+    void linkHierarchy(Writable &w) override;
 
     /**
      * @brief Access an iteration in read mode that has potentially not been
@@ -450,6 +474,10 @@ class Iteration : public Attributable
      *
      */
     void runDeferredParseAccess();
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // Iteration
 
 namespace traits
@@ -458,8 +486,8 @@ namespace traits
     struct GenerationPolicy<Iteration>
     {
         constexpr static bool is_noop = false;
-        template <typename Iterator>
-        void operator()(Iterator &it)
+        template <typename Container, typename Iterator>
+        void operator()(Container &, Iterator &it)
         {
             it->second.get().m_iterationIndex = it->first;
         }
@@ -513,4 +541,10 @@ class IndexedIteration : public Iteration
         : Iteration(std::forward<Iteration_t>(it)), iterationIndex(index)
     {}
 };
+
+class Iterations : public Container<Iteration, Iteration::IterationIndex_t>
+{
+public:
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+};
 } // namespace openPMD
diff --git a/include/openPMD/Mesh.hpp b/include/openPMD/Mesh.hpp
index d0bf81ddef..bf8ad794fb 100644
--- a/include/openPMD/Mesh.hpp
+++ b/include/openPMD/Mesh.hpp
@@ -23,7 +23,10 @@
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
 
 #include <ostream>
 #include <string>
@@ -41,6 +44,8 @@ class Mesh : public BaseRecord<MeshRecordComponent>
 {
     friend class Container<Mesh>;
     friend class Iteration;
+    friend class internal::ScientificDefaults;
+    friend class Attributable;
 
 public:
     Mesh(Mesh const &) = default;
@@ -322,12 +327,19 @@ class Mesh : public BaseRecord<MeshRecordComponent>
         typename = std::enable_if_t<std::is_floating_point<T>::value>>
     Mesh &setTimeOffset(T timeOffset);
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
 private:
     Mesh();
 
     void
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
+    auto retrieveDimensionality() const -> uint64_t;
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // Mesh
 
 template <typename T>
diff --git a/include/openPMD/ParticlePatches.hpp b/include/openPMD/ParticlePatches.hpp
index f3c4c0b943..ffe539d5f1 100644
--- a/include/openPMD/ParticlePatches.hpp
+++ b/include/openPMD/ParticlePatches.hpp
@@ -38,6 +38,8 @@ class ParticlePatches : public Container<PatchRecord>
     size_t numPatches() const;
     ~ParticlePatches() override = default;
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
 private:
     ParticlePatches() = default;
     void read();
diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp
index 7309afddef..7b13a39784 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -24,23 +24,32 @@
 #include "openPMD/Record.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
 
 #include <string>
 
 namespace openPMD
 {
 
-class ParticleSpecies : public Container<Record>
+class ParticleSpecies
+    : public Container<Record>
+    , internal::ScientificDefaults
 {
     friend class Container<ParticleSpecies>;
     friend class Container<Record>;
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults;
+    friend class Attributable;
 
 public:
     ParticlePatches particlePatches;
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
 private:
     ParticleSpecies();
 
@@ -53,6 +62,10 @@ class ParticleSpecies : public Container<Record>
     {
         return m_containerData;
     }
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 };
 
 namespace traits
@@ -61,8 +74,8 @@ namespace traits
     struct GenerationPolicy<ParticleSpecies>
     {
         constexpr static bool is_noop = false;
-        template <typename T>
-        void operator()(T &it)
+        template <typename Container, typename T>
+        void operator()(Container &, T &it)
         {
             it->second.particlePatches.linkHierarchy(it->second.writable());
         }
diff --git a/include/openPMD/Record.hpp b/include/openPMD/Record.hpp
index 2bb070365f..af397925dc 100644
--- a/include/openPMD/Record.hpp
+++ b/include/openPMD/Record.hpp
@@ -23,6 +23,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <string>
 #include <type_traits>
@@ -34,6 +35,7 @@ class Record : public BaseRecord<RecordComponent>
     friend class Container<Record>;
     friend class Iteration;
     friend class ParticleSpecies;
+    friend class internal::ScientificDefaults;
 
 public:
     Record(Record const &) = default;
@@ -48,6 +50,8 @@ class Record : public BaseRecord<RecordComponent>
     template <typename T>
     Record &setTimeOffset(T);
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
 private:
     Record();
 
@@ -55,6 +59,10 @@ class Record : public BaseRecord<RecordComponent>
     flush_impl(std::string const &, internal::FlushParams const &) override;
 
     [[nodiscard]] internal::HomogenizeExtents read();
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // Record
 
 template <typename T>
diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp
index d06b4213f4..425eab273b 100644
--- a/include/openPMD/RecordComponent.hpp
+++ b/include/openPMD/RecordComponent.hpp
@@ -27,6 +27,8 @@
 #include "openPMD/auxiliary/UniquePtr.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 // comment to prevent this include from being moved by clang-format
 #include "openPMD/DatatypeMacros.hpp"
@@ -110,7 +112,9 @@ namespace internal
 template <typename>
 class BaseRecord;
 
-class RecordComponent : public BaseRecordComponent
+class RecordComponent
+    : public BaseRecordComponent
+    , protected internal::ScientificDefaults
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -128,6 +132,9 @@ class RecordComponent : public BaseRecordComponent
     friend class MeshRecordComponent;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults;
+    friend class Attributable;
+    friend class CustomHierarchy;
 
 public:
     enum class Allocation
@@ -482,11 +489,13 @@ class RecordComponent : public BaseRecordComponent
     auto visit(Args &&...args) -> decltype(Visitor::template call<char>(
         std::declval<RecordComponent &>(), std::forward<Args>(args)...));
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
     static constexpr char const *const SCALAR = "\vScalar";
 
 protected:
     void flush(std::string const &, internal::FlushParams const &);
-    void read(bool require_unit_si);
+    void read();
 
 private:
     /**
@@ -534,12 +543,16 @@ OPENPMD_protected
         BaseRecordComponent::setData(m_recordComponentData);
     }
 
-    void readBase(bool require_unit_si);
+    void readBase();
 
     template <typename T>
     void verifyChunk(Offset const &, Extent const &) const;
 
     void verifyChunk(Datatype, Offset const &, Extent const &) const;
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // RecordComponent
 
 namespace internal
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
index b796ab1a93..523f4f1e41 100644
--- a/include/openPMD/RecordComponent.tpp
+++ b/include/openPMD/RecordComponent.tpp
@@ -90,6 +90,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
     {
         size *= ext;
     }
+
     /*
      * Flushing the skeleton does not create datasets,
      * so we might need to do it now.
@@ -129,7 +130,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
              * actual data yet.
              */
             seriesFlush_impl</* flush_entire_series = */ false>(
-                {FlushLevel::SkeletonOnly});
+                {FlushLevel::SkeletonOnly}, /*flush_io_handler=*/false);
             Parameter<Operation::CREATE_DATASET> dCreate(rc.m_dataset.value());
             dCreate.name = Attributable::get().m_writable.ownKeyWithinParent;
             IOHandler()->enqueue(IOTask(this, dCreate));
diff --git a/include/openPMD/Series.hpp b/include/openPMD/Series.hpp
index 603e540c2b..0031f2be5b 100644
--- a/include/openPMD/Series.hpp
+++ b/include/openPMD/Series.hpp
@@ -31,7 +31,9 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
 #include "openPMD/backend/ParsePreference.hpp"
+#include "openPMD/backend/PerIterationData.hpp"
 #include "openPMD/config.hpp"
 #include "openPMD/snapshots/Snapshots.hpp"
 #include "openPMD/version.hpp"
@@ -64,7 +66,6 @@ namespace openPMD
 class ReadIterations;
 class StatefulIterator;
 class Series;
-class Series;
 
 namespace internal
 {
@@ -100,8 +101,8 @@ namespace internal
         SeriesData &operator=(SeriesData &&) = delete;
 
         using IterationIndex_t = Iteration::IterationIndex_t;
-        using IterationsContainer_t = Container<Iteration, IterationIndex_t>;
-        IterationsContainer_t iterations{};
+        using IterationsContainer_t = Iterations;
+        Iterations iterations{};
 
         /**
          * Series::readIterations() returns an iterator type that modifies the
@@ -205,14 +206,18 @@ namespace internal
          * Detected IO format (backend).
          */
         Format m_format;
-        /**
-         *  Whether a step is currently active for this iteration.
-         * Used for group-based iteration layout, see SeriesData.hpp for
-         * iteration-based layout.
-         * Access via stepStatus() method to automatically select the correct
-         * one among both flags.
+
+        /*
+         * This stores data items that are:
+         *
+         * 1. global in group and variable encodings
+         * 2. per-iteration in file encoding
+         *
+         * The struct is stored as part of the Series and as part of each
+         * Iteration. Access must be distinguished by iteration encoding.
          */
-        StepStatus m_stepStatus = StepStatus::NoStep;
+        PerIterationData m_perIterationData;
+
         /**
          * True if a user opts into lazy parsing.
          */
@@ -261,7 +266,6 @@ namespace internal
 
         struct RankTableData
         {
-            Attributable m_attributable;
             std::variant<
                 NoSourceSpecified,
                 SourceSpecifiedViaJSON,
@@ -385,7 +389,7 @@ class Series : public Attributable
      * Type for a container of Iterations indexed by IterationIndex_t.
      */
     using IterationsContainer_t = internal::SeriesData::IterationsContainer_t;
-    IterationsContainer_t iterations;
+    Iterations iterations;
 
     /**
      * @brief Is this a usable Series object?
@@ -447,6 +451,11 @@ class Series : public Attributable
      * <CODE>basePath</CODE>.
      */
     std::string meshesPath() const;
+    /**
+     * @return  String representing the path to mesh records, relative(!) to
+     * <CODE>basePath</CODE>.
+     */
+    std::optional<std::string> meshesPathOptional() const;
     /** Set the path to <A
      * HREF="https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#mesh-based-records">mesh
      * records</A>, relative(!) to <CODE>basePath</CODE>.
@@ -502,6 +511,11 @@ class Series : public Attributable
      * <CODE>basePath</CODE>.
      */
     std::string particlesPath() const;
+    /**
+     * @return  String representing the path to particle species, relative(!) to
+     * <CODE>basePath</CODE>.
+     */
+    std::optional<std::string> particlesPathOptional() const;
     /** Set the path to groups for each <A
      * HREF="https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#particle-records">particle
      * species</A>, relative(!) to <CODE>basePath</CODE>.
@@ -778,6 +792,8 @@ class Series : public Attributable
      */
     void close();
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
     /**
      * This overrides Attributable::iterationFlush() which will fail on Series.
      */
@@ -898,9 +914,7 @@ OPENPMD_private
         iterations_iterator end,
         internal::FlushParams const &flushParams,
         bool flushIOHandler = true);
-    void flushMeshesPath();
-    void flushParticlesPath();
-    void flushRankTable();
+    void flushRankTable(FlushLevel, Attributable &attributable);
     /* Parameter `read_only_this_single_iteration` used for reopening an
      * Iteration after closing it.
      */
@@ -983,8 +997,9 @@ OPENPMD_private
      *        least one step was written.
      *
      * @param doFlush If true, flush the IO handler.
+     * @param l This operation must only run at flush level write_datasets
      */
-    void flushStep(bool doFlush);
+    void flushStep(bool doFlush, FlushLevel l);
 
     /*
      * setIterationEncoding() should only be called by users of our public API,
@@ -995,6 +1010,9 @@ OPENPMD_private
     Series &setIterationEncoding_internal(
         IterationEncoding iterationEncoding, internal::default_or_explicit);
 
+    Series &setParticlesPath_internal(std::string const &particlesPath);
+    Series &setMeshesPath_internal(std::string const &meshesPath);
+
     /*
      * Returns the current content of the /data/snapshot attribute.
      * (We could also add this to the public API some time)
diff --git a/include/openPMD/auxiliary/Defer.hpp b/include/openPMD/auxiliary/Defer.hpp
index c6bc4e0533..505f5fcd39 100644
--- a/include/openPMD/auxiliary/Defer.hpp
+++ b/include/openPMD/auxiliary/Defer.hpp
@@ -21,7 +21,8 @@ struct defer_type
         std::move(functor)();
     }
 
-    explicit defer_type() = default;
+    explicit defer_type() : do_run_this(false)
+    {}
 
     struct forwarding_tag
     {};
diff --git a/include/openPMD/auxiliary/MonadicOperations.hpp b/include/openPMD/auxiliary/MonadicOperations.hpp
new file mode 100644
index 0000000000..c96f682bc8
--- /dev/null
+++ b/include/openPMD/auxiliary/MonadicOperations.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <optional>
+#include <type_traits>
+
+namespace openPMD::auxiliary
+{
+template <typename Optional, typename F>
+auto optional_and_then(Optional &&arg, F &&then)
+    -> std::invoke_result_t<F, decltype(*std::declval<Optional &&>())>
+{
+    if (!arg.has_value())
+    {
+        return std::nullopt;
+    }
+    return std::forward<F>(then)(*std::forward<Optional>(arg));
+}
+} // namespace openPMD::auxiliary
diff --git a/include/openPMD/auxiliary/TypeTraits.hpp b/include/openPMD/auxiliary/TypeTraits.hpp
index faf2b29472..b395c199e1 100644
--- a/include/openPMD/auxiliary/TypeTraits.hpp
+++ b/include/openPMD/auxiliary/TypeTraits.hpp
@@ -124,6 +124,22 @@ namespace detail
     {
         constexpr static bool value = true;
     };
+
+    template <typename T>
+    struct ScalarType
+    {
+        using type = T;
+    };
+    template <typename T>
+    struct ScalarType<std::vector<T>>
+    {
+        using type = T;
+    };
+    template <typename T, size_t N>
+    struct ScalarType<std::array<T, N>>
+    {
+        using type = T;
+    };
 } // namespace detail
 
 template <typename T>
@@ -141,6 +157,15 @@ using IsPointer_t = typename detail::IsPointer<T>::type;
 template <typename C>
 inline constexpr bool IsChar_v = detail::IsChar<C>::value;
 
+template <typename T>
+using ScalarType_t = typename detail::ScalarType<T>::type;
+
+template <typename T>
+using VectorType_t = std::vector<ScalarType_t<T>>;
+
+template <bool const_, typename T>
+using dependent_const = std::conditional_t<const_, T const, T>;
+
 /** Emulate in the C++ concept ContiguousContainer
  *
  * Users can implement this trait for a type to signal it can be used as
@@ -203,6 +228,37 @@ namespace detail
     // little trick to avoid trailing commas in the macro expansions below
     template <typename Arg, typename... Args>
     using variant_tail_t = std::variant<Args...>;
+
+    template <template <typename...> class Base, typename... Args>
+    auto infer_template_args(Base<Args...> &) -> Base<Args...>;
+
+    template <template <typename...> class Base, typename... Args>
+    auto infer_template_args(Base<Args...> const &) -> Base<Args...>;
+
+    template <
+        template <typename...> class Base,
+        typename T,
+        typename SFINAE = void>
+    struct IsTemplateBaseOf
+    {
+        static constexpr bool value = false;
+    };
+
+    template <template <typename...> class Base, typename T>
+    struct IsTemplateBaseOf<
+        Base,
+        T,
+        std::void_t<decltype(detail::infer_template_args<Base>(
+            std::declval<T &>()))>>
+    {
+        static constexpr bool value = true;
+        using type =
+            decltype(detail::infer_template_args<Base>(std::declval<T &>()));
+    };
 } // namespace detail
 
+template <template <typename...> class Base, typename T>
+constexpr bool IsTemplateBaseOf_v = detail::IsTemplateBaseOf<Base, T>::value;
+template <template <typename...> class Base, typename T>
+using AsTemplateBase_t = typename detail::IsTemplateBaseOf<Base, T>::type;
 } // namespace openPMD::auxiliary
diff --git a/include/openPMD/backend/Attributable.hpp b/include/openPMD/backend/Attributable.hpp
index 705080be84..2a0ec6fd81 100644
--- a/include/openPMD/backend/Attributable.hpp
+++ b/include/openPMD/backend/Attributable.hpp
@@ -25,6 +25,7 @@
 #include "openPMD/ThrowError.hpp"
 #include "openPMD/auxiliary/OutOfRangeMsg.hpp"
 #include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
 #include "openPMD/backend/Writable.hpp"
 
 #include <cstddef>
@@ -51,12 +52,16 @@ class AbstractFilePosition;
 class Attributable;
 class Iteration;
 class Series;
+class CustomHierarchy;
 
 namespace internal
 {
     class IterationData;
     class SeriesData;
     struct HomogenizeExtents;
+    struct ConfigAttribute;
+    class ScientificDefaults;
+    class AttributableData;
 
     class SharedAttributableData
     {
@@ -84,6 +89,25 @@ namespace internal
          * The attributes defined by this Attributable.
          */
         A_MAP m_attributes;
+
+        // Using shared_ptr<SharedAttributableData> in here because
+        // AttributableData is non-copyable and non-movable, but we need
+        // movability for map handling
+        // Disallowing move in AttributableData is only a measure for code
+        // discipline anyway.
+        using children_map_t =
+            std::map<std::string, std::shared_ptr<SharedAttributableData>>;
+        children_map_t m_children;
+
+        // Attributable::customHierarchies() creates objects of type
+        // CustomHierarchy ephemerally on the spot. If that object is the first
+        // object for its associated SharedAttributableData instance, it must be
+        // stored somewhere still, because the first instance is back-referenced
+        // by Writable class (TODO: turn that back-reference into a weak_ptr?).
+        // Store these objects in the parent to avoid reference cycles.
+        using children_object_storage_t =
+            std::map<std::string, CustomHierarchy>;
+        children_object_storage_t m_children_managed_as_custom_hierarchy;
     };
 
     /*
@@ -109,6 +133,8 @@ namespace internal
 
         using SharedData_t = std::shared_ptr<SharedAttributableData>;
         using A_MAP = SharedData_t::element_type::A_MAP;
+        using parent_t = std::shared_ptr<SharedAttributableData>;
+        friend class openPMD::CustomHierarchy;
 
     public:
         AttributableData();
@@ -117,12 +143,24 @@ namespace internal
         AttributableData(AttributableData &&) = delete;
         virtual ~AttributableData() = default;
 
+        inline auto asSharedPtrOfAttributable()
+            -> std::shared_ptr<SharedAttributableData> &
+        {
+            return *this;
+        }
+
+        [[nodiscard]] inline auto asSharedPtrOfAttributable() const
+            -> std::shared_ptr<SharedAttributableData> const &
+        {
+            return *this;
+        }
+
         AttributableData &operator=(AttributableData const &) = delete;
         AttributableData &operator=(AttributableData &&) = delete;
 
         // Make copies explicit, only to be used under the conditions described
         // above
-        void cloneFrom(AttributableData const &other);
+        void cloneFrom(parent_t const &other);
 
         template <typename T>
         T asInternalCopyOf()
@@ -244,6 +282,9 @@ class Attributable
     friend class internal::AttributableData;
     friend class Snapshots;
     friend struct internal::HomogenizeExtents;
+    friend struct internal::ConfigAttribute;
+    friend class internal::ScientificDefaults;
+    friend class CustomHierarchy;
 
 protected:
     // tag for internal constructor
@@ -276,6 +317,7 @@ class Attributable
     template <typename T>
     bool setAttribute(std::string const &key, T value);
     bool setAttribute(std::string const &key, char const value[]);
+    bool setAttribute(std::string const &key, Attribute value);
     /** @}
      */
 
@@ -288,6 +330,15 @@ class Attributable
      */
     Attribute getAttribute(std::string const &key) const;
 
+    /** Retrieve value of Attribute stored with provided key.
+     *
+     * @throw   no_such_attribute_error If no Attribute is currently stored with
+     * the provided key.
+     * @param   key Key (i.e. name) of the Attribute to retrieve value for.
+     * @return  If found, the stored Attribute in Variant form.
+     */
+    std::optional<Attribute> getAttributeOptional(std::string const &key) const;
+
     /** Remove Attribute of provided value both logically and physically.
      *
      * @param   key Key (i.e. name) of the Attribute to remove.
@@ -357,6 +408,8 @@ class Attributable
      */
     void iterationFlush(std::string backendConfig = "{}");
 
+    void customHierarchyFlush(internal::FlushParams const &, bool unset_dirty);
+
     /** String serialization to describe an Attributable
      *
      * This object contains the Series data path as well as the openPMD object
@@ -398,8 +451,76 @@ class Attributable
      */
     void touch();
 
+    /**
+     * Visitor pattern for the openPMD object hierarchy in postfix traversal.
+     *
+     * @note As the HierarchyVisitor interface can be tedious to implement,
+     *       consider using visitHierarchyFromLambda for a more convenient
+     *       interface.
+
+     * @note to developers: if at any point a prefix traversal should become
+     *       necessary, consider emplacing configuration options for this inside
+     *       HierarchyVisitor to keep the interface clean.
+     *
+     * @param visitor Operations to run for each object.
+     * @param recursive Extend the operation recursively to children.
+     */
+    virtual void visitHierarchy(HierarchyVisitor &visitor, bool recursive);
+
+    /**
+     * Visitor pattern for the openPMD object hierarchy in postfix traversal,
+     * lambda version.
+     *
+     * The lambda parameter will be called with a reference to each object in
+     * the current object's enclosed hierarchy.
+     *
+     * @note Definition inside include/openPMD/backend/HierarchyVisitorImpl.hpp.
+     * @param lambda Operations to run for each object.
+     * @param recursive Extend the operation recursively to children.
+     */
+    template <typename Lambda>
+    void visitHierarchyFromLambda(Lambda &&lambda, bool recursive);
+
+    /** Create standard defined attributes with default values now, insofar they
+     *  are still missing. Does not flush.
+     *
+     * Refer to
+     * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md
+     * for the attributes implied by this operation.
+     *
+     * By default, standard defined attributes are written upon closing the
+     * containing Iteration / Series. Calling this soon can make data available
+     * for early readers (e.g. read while the writer is still modifying). In
+     * workflows that keep single Iterations open over an extended period of
+     * time (e.g. back-transformed diagnostics), this can help creating readable
+     * files earlier than without.
+     *
+     * Attributes may still be modified after this as usual. Attributes defined
+     * before this call will not be modified by it.
+     *
+     * @param recursive Extend the operation recursively to children.
+     */
+    void populateMissingMetadata(bool recursive);
+
     [[nodiscard]] OpenpmdStandard openPMDStandard() const;
 
+    // TODO: Add parse? parameter, dont parse, parse this object, parse
+    // recursively
+    // Alternatively, parse upon deferred initialization?
+    // TODO CustomHierarchy is ephemeral, and i dont even know what that word
+    // means. but i want to say that things are created on the spot. if we go to
+    // the same place in the openPMD file using different paths, the objects
+    // will be different, except for the backend data stored in
+    // sharedattributabledata and writable classes. even when later turning a
+    // customhierarchy object into a recordcomponent, this will not be same
+    // recordcomponent object as in the usual openpmd hierarchy.
+    // TODO if objects are *created* by customhierarchies, the pointer
+    // writable.attributable will point to that object as the first instance. so
+    // i guess we will still need to store the objects somewhere and cannot keep
+    // them fully ephemeral. likely a resource container in the parent (to break
+    // reference cycles).
+    auto customHierarchies() -> CustomHierarchy;
+
     // clang-format off
 OPENPMD_protected
     // clang-format on
@@ -421,7 +542,7 @@ OPENPMD_protected
     /** @} */
 
     template <bool flush_entire_series>
-    void seriesFlush_impl(internal::FlushParams const &);
+    void seriesFlush_impl(internal::FlushParams const &, bool flush_io_handler);
 
     void flushAttributes(internal::FlushParams const &);
 
@@ -525,6 +646,8 @@ OPENPMD_protected
         return (*m_attri)->m_writable;
     }
 
+    void preferCurrentBackpointer() const;
+
     inline void setData(std::shared_ptr<internal::AttributableData> attri)
     {
         m_attri = std::move(attri);
@@ -549,6 +672,27 @@ OPENPMD_protected
     {
         return writable().dirtyRecursive;
     }
+    void determineUnsetDirty(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            setDirty(false);
+            break;
+        case FlushLevel::InternalFlush:
+            // Used for parsing
+            if (IOHandler()->m_seriesStatus == internal::SeriesStatus::Parsing)
+            {
+                throw error::Internal(
+                    "Parsing procedures should directly unset dirty.");
+            }
+            break;
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            // noop
+            break;
+        }
+    }
     void setDirty(bool dirty_in)
     {
         auto &w = writable();
@@ -673,6 +817,6 @@ Attributable::readVectorFloatingpoint(std::string const &key) const
         std::is_floating_point<T>::value,
         "Type of attribute must be floating point");
 
-    return getAttribute(key).get<std::vector<T> >();
+    return getAttribute(key).get<std::vector<T>>();
 }
 } // namespace openPMD
diff --git a/include/openPMD/backend/Attribute.hpp b/include/openPMD/backend/Attribute.hpp
index 9dc621d6e7..c69d4bb7b3 100644
--- a/include/openPMD/backend/Attribute.hpp
+++ b/include/openPMD/backend/Attribute.hpp
@@ -115,9 +115,42 @@ class Attribute
     template <typename U>
     std::optional<U> getOptional() const;
 
-private:
+    /** Retrieve a stored specific Attribute and cast if convertible.
+     *  Like Attribute::get<>(), but returns an exception instead of throwing it
+     * if no conversion is possible.
+     *
+     * @note This performs a static_cast and might introduce precision loss if
+     *       requested. Check dtype explicitly beforehand if needed.
+     *
+     * @tparam  U   Type of the object to be casted to.
+     * @return  Copy of the retrieved object, casted to type U.
+     *          A runtime_error (as return value, no thrown) if no conversion is
+     *          possible.
+     */
     template <typename U>
-    std::variant<U, std::runtime_error> get_impl() const;
+    std::variant<U, std::runtime_error> getOrError() const;
+
+    /**
+     * Force this attribute into a vector type.
+     * If it is scalar, convert to a vector with a single element.
+     * If it is an array, convert it to a vector.
+     *
+     * @return On success, a new Attribute with underlying vector type.
+     *         On failure, an error with a description of what went wrong
+     *         (e.g. when the base type is bool).
+     */
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireVector() const;
+    /**
+     * Force this attribute into a scalar type.
+     * If it is a vector attribute with a single entry, convert to a scalar.
+     *
+     * @return On success, a new Attribute with underlying scalar type.
+     *         On failure, an error with a description of what went wrong
+     *         (e.g. when a vector with size other than 1 was provided).
+     */
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireScalar() const;
 };
 
 namespace detail
diff --git a/include/openPMD/backend/BaseRecord.hpp b/include/openPMD/backend/BaseRecord.hpp
index f75536e3bd..b8940fcf29 100644
--- a/include/openPMD/backend/BaseRecord.hpp
+++ b/include/openPMD/backend/BaseRecord.hpp
@@ -26,6 +26,8 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <array>
 #include <stdexcept>
@@ -179,6 +181,8 @@ template <typename T_elem>
 class BaseRecord
     : public Container<T_elem>
     , public T_elem // T_RecordComponent
+// ScientificDefaults already inherited via RecordComponent
+// , internal::ScientificDefaults
 {
 public:
     using T_RecordComponent = T_elem;
@@ -197,6 +201,7 @@ class BaseRecord
     friend class internal::ScalarIterator;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class internal::ScientificDefaults;
 
     using Data_t =
         internal::BaseRecordData<T_elem, typename T_RecordComponent::Data_t>;
@@ -362,15 +367,16 @@ class BaseRecord
      */
     bool scalar() const;
 
-protected:
-    void readBase();
-
 private:
     void flush(std::string const &, internal::FlushParams const &) final;
     virtual void
     flush_impl(std::string const &, internal::FlushParams const &) = 0;
 
     void eraseScalar();
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // BaseRecord
 
 namespace detail
@@ -381,6 +387,21 @@ namespace detail
 
     template <typename BaseRecord>
     void verifyNonscalar(BaseRecord *self);
+
+    template <typename T>
+    struct IsBaseRecord
+    {
+        constexpr static bool value = false;
+    };
+
+    template <typename T>
+    struct IsBaseRecord<BaseRecord<T>>
+    {
+        constexpr static bool value = true;
+    };
+
+    template <typename T>
+    constexpr bool IsBaseRecord_v = IsBaseRecord<T>::value;
 } // namespace detail
 
 template <typename T_elem>
@@ -388,10 +409,12 @@ template <typename... Args>
 auto BaseRecord<T_elem>::emplace(Args &&...args) -> std::pair<iterator, bool>
 {
     detail::verifyNonscalar(this);
-    auto res = this->container().emplace(std::forward<Args>(args)...);
+    auto res = this->syncInsertResult(
+        this->container_front().emplace(std::forward<Args>(args)...));
     if (res.first->first == RecordComponent::SCALAR)
     {
-        this->container().erase(res.first);
+        this->container_back(/* verify = */ true).erase(res.first->first);
+        this->container_front().erase(res.first);
         throw error::WrongAPIUsage(detail::NO_SCALAR_INSERT);
     }
     return {makeIterator(std::move(res.first)), res.second};
diff --git a/include/openPMD/backend/BaseRecordComponent.hpp b/include/openPMD/backend/BaseRecordComponent.hpp
index b3c85f869d..af23e08468 100644
--- a/include/openPMD/backend/BaseRecordComponent.hpp
+++ b/include/openPMD/backend/BaseRecordComponent.hpp
@@ -82,6 +82,7 @@ class BaseRecordComponent : virtual public Attributable
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
+    friend class Attributable;
 
 public:
     /*
diff --git a/include/openPMD/backend/Container.hpp b/include/openPMD/backend/Container.hpp
index 963fd34802..5e7bf1040f 100644
--- a/include/openPMD/backend/Container.hpp
+++ b/include/openPMD/backend/Container.hpp
@@ -22,7 +22,9 @@
 
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/Access.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
 
 #include <initializer_list>
 #include <map>
@@ -51,18 +53,41 @@ namespace traits
     struct GenerationPolicy
     {
         constexpr static bool is_noop = true;
-        template <typename T>
-        void operator()(T &)
+        template <typename Container, typename T>
+        void operator()(Container &, T &)
+        {}
+    };
+
+    template <typename Container_t>
+    struct DeferredInitPolicy
+    {
+        static void call(Container_t &)
+        {}
+        static void call(Container_t const &)
         {}
     };
 } // namespace traits
 
+class CustomHierarchy;
+
 namespace internal
 {
     class SeriesData;
     template <typename>
     class EraseStaleEntries;
 
+    template <typename T>
+    constexpr inline bool isDerivedFromAttributable =
+        std::is_base_of_v<Attributable, T>;
+
+    /*
+     * Opt out from this check due to the recursive definition of
+     * class CustomHierarchy : public Container<CustomHierarchy>{ ... };
+     * Cannot check this while CustomHierarchy is still an incomplete type.
+     */
+    template <>
+    constexpr inline bool isDerivedFromAttributable<CustomHierarchy> = true;
+
     template <
         typename T,
         typename T_key = std::string,
@@ -103,7 +128,7 @@ template <
 class Container : virtual public Attributable
 {
     static_assert(
-        std::is_base_of<Attributable, T>::value,
+        internal::isDerivedFromAttributable<T>,
         "Type of container element must be derived from Writable");
 
     friend class Iteration;
@@ -115,10 +140,64 @@ class Container : virtual public Attributable
     friend class internal::EraseStaleEntries;
     friend class StatefulIterator;
 
+    using Self_t = Container<T, T_key, T_container>;
+    friend struct traits::DeferredInitPolicy<Self_t>;
+
 protected:
     using ContainerData = internal::ContainerData<T, T_key, T_container>;
     using InternalContainer = T_container;
 
+    using stringify_t = std::conditional_t<
+        std::is_same_v<T_key, std::string>,
+        std::string const &,
+        std::string>;
+    static auto key_as_string(T_key const &key) -> stringify_t
+    {
+        if constexpr (std::is_same_v<T_key, std::string>)
+        {
+            return key;
+        }
+        else
+        {
+            return std::to_string(key);
+        }
+    }
+
+    template <bool const_>
+    struct SynchronizedContainers
+    {
+        using front_t = auxiliary::dependent_const<const_, T_container>;
+        using back_t = auxiliary::dependent_const<
+            const_,
+            internal::SharedAttributableData::children_map_t>;
+
+        front_t *front;
+        back_t *back;
+
+        template <typename Functor>
+        inline auto for_both(Functor &&f)
+        {
+            f(*this->front);
+            return f(*this->back);
+        }
+
+        template <typename Functor>
+        inline auto for_both_to_string(Functor &&f)
+        {
+            f(*this->front, [](auto key) { return key; });
+            if constexpr (std::is_same_v<T_key, std::string>)
+            {
+                return f(*this->back, [](auto key) { return key; });
+            }
+            else
+            {
+                return f(
+                    *this->back,
+                    static_cast<std::string (*)(T_key)>(&std::to_string));
+            }
+        }
+    };
+
     std::shared_ptr<ContainerData> m_containerData;
 
     inline void setData(std::shared_ptr<ContainerData> containerData)
@@ -127,16 +206,72 @@ class Container : virtual public Attributable
         Attributable::setData(m_containerData);
     }
 
-    inline InternalContainer const &container() const
+    inline SynchronizedContainers<true> container() const
+    {
+#ifndef NDEBUG
+        auto size_front = container_front().size();
+        auto size_back = container_back(/* verify = */ true).size();
+        if (size_front > size_back)
+        {
+            throw std::runtime_error(
+                "Invalid container state: " + std::to_string(size_front) +
+                " != " + std::to_string(size_back) + ".");
+        }
+#endif
+        traits::DeferredInitPolicy<Self_t>::call(*this);
+        return {&container_front(), &container_back(/* verify = */ true)};
+    }
+
+    inline SynchronizedContainers<false> container()
+    {
+#ifndef NDEBUG
+        auto size_front = container_front().size();
+        auto size_back = container_back(/* verify = */ true).size();
+        if (size_front > size_back)
+        {
+            throw std::runtime_error(
+                "Invalid container state: " + std::to_string(size_front) +
+                " != " + std::to_string(size_back) + ".");
+        }
+#endif
+        traits::DeferredInitPolicy<Self_t>::call(*this);
+        return {&container_front(), &container_back(/* verify = */ true)};
+    }
+
+    inline auto container_front() const ->
+        typename SynchronizedContainers<true>::front_t &
     {
+        traits::DeferredInitPolicy<Self_t>::call(*this);
         return m_containerData->m_container;
     }
 
-    inline InternalContainer &container()
+    inline auto container_front() ->
+        typename SynchronizedContainers<false>::front_t &
     {
+        traits::DeferredInitPolicy<Self_t>::call(*this);
         return m_containerData->m_container;
     }
 
+    inline auto container_back(bool verify) const ->
+        typename SynchronizedContainers<true>::back_t &
+    {
+        if (verify)
+        {
+            traits::DeferredInitPolicy<Self_t>::call(*this);
+        }
+        return Attributable::get().m_children;
+    }
+
+    inline auto container_back(bool verify) ->
+        typename SynchronizedContainers<false>::back_t &
+    {
+        if (verify)
+        {
+            traits::DeferredInitPolicy<Self_t>::call(*this);
+        }
+        return Attributable::get().m_children;
+    }
+
 public:
     using key_type = typename InternalContainer::key_type;
     using mapped_type = typename InternalContainer::mapped_type;
@@ -258,7 +393,21 @@ class Container : virtual public Attributable
     auto emplace(Args &&...args)
         -> decltype(InternalContainer().emplace(std::forward<Args>(args)...))
     {
-        return container().emplace(std::forward<Args>(args)...);
+        return syncInsertResult(
+            container_front().emplace(std::forward<Args>(args)...));
+    }
+
+    template <typename ChildClass>
+    void visitHierarchyImpl(HierarchyVisitor &v, bool recursive)
+    {
+        if (recursive)
+        {
+            for (auto &p : *this)
+            {
+                p.second.visitHierarchy(v, recursive);
+            }
+        }
+        v(*static_cast<ChildClass *>(this));
     }
 
     // clang-format off
@@ -274,6 +423,34 @@ OPENPMD_protected
 
     Container(NoInit);
 
+    auto syncInsertResult(std::pair<iterator, bool> res)
+        -> std::pair<iterator, bool>
+    {
+        if (res.second)
+        {
+            syncInsertResult(res.first);
+        }
+        return res;
+    }
+    auto syncInsertResult(iterator res) -> iterator
+    {
+        auto &cont = container_back(/* verify = */ false);
+        decltype(auto) key = key_as_string(res->first);
+        auto it = cont.find(key);
+        if (it == cont.end())
+        {
+            cont.emplace(key_as_string(res->first), *res->second.m_attri);
+        }
+        else
+        {
+            // uhhm this might cause edge cases
+            // backend value is older, so it gets seniority
+            res->second.m_attri->asSharedPtrOfAttributable() = it->second;
+            res->second.preferCurrentBackpointer();
+        }
+        return res;
+    }
+
 public:
     /*
      * Need to define these manually due to the virtual inheritance from
diff --git a/include/openPMD/backend/ContainerImpl.tpp b/include/openPMD/backend/ContainerImpl.tpp
index de11c91f14..144f9f373d 100644
--- a/include/openPMD/backend/ContainerImpl.tpp
+++ b/include/openPMD/backend/ContainerImpl.tpp
@@ -19,6 +19,7 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
 
 /*
@@ -33,101 +34,101 @@ namespace openPMD
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::begin() noexcept -> iterator
 {
-    return container().begin();
+    return container_front().begin();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::begin() const noexcept -> const_iterator
 {
-    return container().begin();
+    return container_front().begin();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::cbegin() const noexcept -> const_iterator
 {
-    return container().cbegin();
+    return container_front().cbegin();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::end() noexcept -> iterator
 {
-    return container().end();
+    return container_front().end();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::end() const noexcept -> const_iterator
 {
-    return container().end();
+    return container_front().end();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::cend() const noexcept -> const_iterator
 {
-    return container().cend();
+    return container_front().cend();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::rbegin() noexcept -> reverse_iterator
 {
-    return container().rbegin();
+    return container_front().rbegin();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::rbegin() const noexcept
     -> const_reverse_iterator
 {
-    return container().rbegin();
+    return container_front().rbegin();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::crbegin() const noexcept
     -> const_reverse_iterator
 {
-    return container().crbegin();
+    return container_front().crbegin();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::rend() noexcept -> reverse_iterator
 {
-    return container().rend();
+    return container_front().rend();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::rend() const noexcept
     -> const_reverse_iterator
 {
-    return container().rend();
+    return container_front().rend();
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::crend() const noexcept
     -> const_reverse_iterator
 {
-    return container().crend();
+    return container_front().crend();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::empty() const noexcept -> bool
 {
-    return container().empty();
+    return container_front().empty();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::size() const noexcept -> size_type
 {
-    return container().size();
+    return container_front().size();
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::at(key_type const &key) -> mapped_type &
 {
-    return container().at(key);
+    return container_front().at(key);
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::at(key_type const &key) const
     -> mapped_type const &
 {
-    return container().at(key);
+    return container_front().at(key);
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::operator[](key_type const &key)
     -> mapped_type &
 {
-    auto it = container().find(key);
-    if (it != container().end())
+    auto it = container_front().find(key);
+    if (it != container_front().end())
         return it->second;
     else
     {
@@ -140,7 +141,9 @@ auto Container<T, T_key, T_container>::operator[](key_type const &key)
 
         T t = T();
         t.linkHierarchy(writable());
-        auto inserted_iterator = container().insert({key, std::move(t)}).first;
+        auto inserted_iterator =
+            syncInsertResult(container_front().insert({key, std::move(t)}))
+                .first;
         auto &ret = inserted_iterator->second;
         if constexpr (std::is_same_v<T_key, std::string>)
         {
@@ -151,7 +154,7 @@ auto Container<T, T_key, T_container>::operator[](key_type const &key)
             ret.writable().ownKeyWithinParent = std::to_string(key);
         }
         traits::GenerationPolicy<T> gen;
-        gen(inserted_iterator);
+        gen(*this, inserted_iterator);
         return ret;
     }
 }
@@ -159,8 +162,8 @@ template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::operator[](key_type &&key)
     -> mapped_type &
 {
-    auto it = container().find(key);
-    if (it != container().end())
+    auto it = container_front().find(key);
+    if (it != container_front().end())
         return it->second;
     else
     {
@@ -173,7 +176,9 @@ auto Container<T, T_key, T_container>::operator[](key_type &&key)
 
         T t = T();
         t.linkHierarchy(writable());
-        auto inserted_iterator = container().insert({key, std::move(t)}).first;
+        auto inserted_iterator =
+            syncInsertResult(container_front().insert({key, std::move(t)}))
+                .first;
         auto &ret = inserted_iterator->second;
         if constexpr (std::is_same_v<T_key, std::string>)
         {
@@ -184,7 +189,7 @@ auto Container<T, T_key, T_container>::operator[](key_type &&key)
             ret.writable().ownKeyWithinParent = std::to_string(std::move(key));
         }
         traits::GenerationPolicy<T> gen;
-        gen(inserted_iterator);
+        gen(*this, inserted_iterator);
         return ret;
     }
 }
@@ -203,49 +208,71 @@ template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::insert(value_type const &value)
     -> std::pair<iterator, bool>
 {
-    return container().insert(value);
+    return syncInsertResult(container_front().insert(value));
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::insert(value_type &&value)
     -> std::pair<iterator, bool>
 {
-    return container().insert(value);
+    return syncInsertResult(container_front().insert(value));
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::insert(
     const_iterator hint, value_type const &value) -> iterator
 {
-    return container().insert(hint, value);
+    return syncInsertResult(container_front().insert(hint, value));
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::insert(
     const_iterator hint, value_type &&value) -> iterator
 {
-    return container().insert(hint, value);
+    return syncInsertResult(container_front().insert(hint, value));
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::insert(
     std::initializer_list<value_type> ilist) -> void
 {
-    container().insert(ilist);
+    std::vector<internal::SharedAttributableData::children_map_t::value_type>
+        internal_insert_list;
+    internal_insert_list.reserve(ilist.size());
+    auto &cont = container_back(/* verify = */ false);
+    for (auto &v : ilist)
+    {
+        decltype(auto) key = key_as_string(v.first);
+        auto it = cont.find(key);
+        if (it == cont.end())
+        {
+            internal_insert_list.emplace_back(key, *v.second.m_attri);
+        }
+        else
+        {
+            // backend value is older, so it gets seniority
+            v.second.m_attri->asSharedPtrOfAttributable() = it->second;
+            v.second.preferCurrentBackpointer();
+        }
+    }
+    container_front().insert(std::move(ilist));
+    cont.insert(internal_insert_list.begin(), internal_insert_list.end());
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::swap(Container &other) -> void
 {
-    container().swap(other.container());
+    container_front().swap(other.container_front());
+    container_back(/* verify = */ true)
+        .swap(other.container_back(/* verify = */ true));
 }
 
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::find(key_type const &key) -> iterator
 {
-    return container().find(key);
+    return container_front().find(key);
 }
 template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::find(key_type const &key) const
     -> const_iterator
 {
-    return container().find(key);
+    return container_front().find(key);
 }
 
 /** This returns either 1 if the key is found in the container of 0 if not.
@@ -257,7 +284,7 @@ template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::count(key_type const &key) const
     -> size_type
 {
-    return container().count(key);
+    return container_front().count(key);
 }
 
 /** Checks if there is an element with a key equivalent to an exiting key in
@@ -270,7 +297,7 @@ template <typename T, typename T_key, typename T_container>
 auto Container<T, T_key, T_container>::contains(key_type const &key) const
     -> bool
 {
-    return container().find(key) != container().end();
+    return container_front().find(key) != container_front().end();
 }
 
 template <typename T, typename T_key, typename T_container>
@@ -280,15 +307,17 @@ auto Container<T, T_key, T_container>::erase(key_type const &key) -> size_type
         throw std::runtime_error(
             "Can not erase from a container in a read-only Series.");
 
-    auto res = container().find(key);
-    if (res != container().end() && res->second.written())
+    auto res = container_front().find(key);
+    if (res != container_front().end() && res->second.written())
     {
         Parameter<Operation::DELETE_PATH> pDelete;
         pDelete.path = ".";
         IOHandler()->enqueue(IOTask(&res->second, pDelete));
         IOHandler()->flush(internal::defaultFlushParams);
     }
-    return container().erase(key);
+    return container().for_both_to_string([&key](auto &map, auto &&to_string) {
+        return map.erase(to_string(key));
+    });
 }
 
 template <typename T, typename T_key, typename T_container>
@@ -298,14 +327,15 @@ auto Container<T, T_key, T_container>::erase(iterator res) -> iterator
         throw std::runtime_error(
             "Can not erase from a container in a read-only Series.");
 
-    if (res != container().end() && res->second.written())
+    if (res != container_front().end() && res->second.written())
     {
         Parameter<Operation::DELETE_PATH> pDelete;
         pDelete.path = ".";
         IOHandler()->enqueue(IOTask(&res->second, pDelete));
         IOHandler()->flush(internal::defaultFlushParams);
     }
-    return container().erase(res);
+    container_back(/* verify = */ true).erase(key_as_string(res->first));
+    return container_front().erase(res);
 }
 
 template <typename T, typename T_key, typename T_container>
@@ -315,7 +345,7 @@ auto Container<T, T_key, T_container>::clear_unchecked() -> void
         throw std::runtime_error(
             "Clearing a written container not (yet) implemented.");
 
-    container().clear();
+    container().for_both([](auto &map) { map.clear(); });
 }
 
 template <typename T, typename T_key, typename T_container>
@@ -329,7 +359,11 @@ auto Container<T, T_key, T_container>::flush(
         IOHandler()->enqueue(IOTask(this, pCreate));
     }
 
-    flushAttributes(flushParams);
+    customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        flushAttributes(flushParams);
+    }
 }
 
 template <typename T, typename T_key, typename T_container>
@@ -421,12 +455,12 @@ namespace internal
     template <typename Container_t>
     EraseStaleEntries<Container_t>::~EraseStaleEntries()
     {
-        auto &map = m_originalContainer.container();
+        auto map = m_originalContainer.container();
         using iterator_t =
             typename Container_t::InternalContainer::const_iterator;
         std::vector<iterator_t> deleteMe;
-        deleteMe.reserve(map.size() - m_accessedKeys.size());
-        for (iterator_t it = map.begin(); it != map.end(); ++it)
+        deleteMe.reserve(map.front->size() - m_accessedKeys.size());
+        for (iterator_t it = map.front->begin(); it != map.front->end(); ++it)
         {
             auto lookup = m_accessedKeys.find(it->first);
             if (lookup == m_accessedKeys.end())
@@ -436,7 +470,8 @@ namespace internal
         }
         for (auto &it : deleteMe)
         {
-            map.erase(it);
+            map.back->erase(it->first);
+            map.front->erase(it);
         }
     }
 } // namespace internal
diff --git a/include/openPMD/backend/HierarchyVisitor.hpp b/include/openPMD/backend/HierarchyVisitor.hpp
new file mode 100644
index 0000000000..389974bb5b
--- /dev/null
+++ b/include/openPMD/backend/HierarchyVisitor.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+namespace openPMD
+{
+class Iteration;
+class Iterations;
+class Mesh;
+class MeshRecordComponent;
+class Meshes;
+class ParticlePatches;
+class ParticleSpecies;
+class Particles;
+class PatchRecord;
+class PatchRecordComponent;
+class Record;
+class RecordComponent;
+class Series;
+
+class HierarchyVisitor
+{
+public:
+    virtual void operator()(Iteration &) = 0;
+    virtual void operator()(Iterations &) = 0;
+    virtual void operator()(Mesh &) = 0;
+    virtual void operator()(MeshRecordComponent &) = 0;
+    virtual void operator()(Meshes &) = 0;
+    virtual void operator()(ParticlePatches &) = 0;
+    virtual void operator()(ParticleSpecies &) = 0;
+    virtual void operator()(Particles &) = 0;
+    virtual void operator()(PatchRecord &) = 0;
+    virtual void operator()(PatchRecordComponent &) = 0;
+    virtual void operator()(Record &) = 0;
+    virtual void operator()(RecordComponent &) = 0;
+    virtual void operator()(Series &) = 0;
+};
+} // namespace openPMD
diff --git a/include/openPMD/backend/HierarchyVisitorImpl.hpp b/include/openPMD/backend/HierarchyVisitorImpl.hpp
new file mode 100644
index 0000000000..91ba076570
--- /dev/null
+++ b/include/openPMD/backend/HierarchyVisitorImpl.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include "openPMD/backend/HierarchyVisitor.hpp"
+
+#include "openPMD/Iteration.hpp"
+#include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/Series.hpp"
+#include <type_traits>
+
+namespace openPMD
+{
+template <typename Lambda>
+class HierarchyVisitorFromLambda : public HierarchyVisitor
+{
+    Lambda lambda;
+
+    template <typename Arg>
+    HierarchyVisitorFromLambda(uint8_t /* constructor_tag */, Arg &&arg)
+        : lambda(std::forward<Arg>(arg))
+    {}
+
+    template <typename Lambda_in>
+    friend auto makeHierarchyVisitorFromLambda(Lambda_in &&lambda);
+
+public:
+    void operator()(Iteration &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Iterations &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Mesh &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(MeshRecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Meshes &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(ParticlePatches &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(PatchRecord &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(ParticleSpecies &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Particles &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(PatchRecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Record &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(RecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Series &obj) override
+    {
+        lambda(obj);
+    }
+};
+
+template <typename Lambda>
+auto makeHierarchyVisitorFromLambda(Lambda &&lambda)
+{
+    using res_t = HierarchyVisitorFromLambda<std::remove_reference_t<Lambda>>;
+    return res_t{0, std::forward<Lambda>(lambda)};
+}
+
+template <typename Lambda>
+void Attributable::visitHierarchyFromLambda(Lambda &&lambda, bool recursive)
+{
+    auto visitor = makeHierarchyVisitorFromLambda(std::forward<Lambda>(lambda));
+    this->visitHierarchy(visitor, recursive);
+}
+} // namespace openPMD
diff --git a/include/openPMD/backend/MeshRecordComponent.hpp b/include/openPMD/backend/MeshRecordComponent.hpp
index 708c4a496f..f359d5904c 100644
--- a/include/openPMD/backend/MeshRecordComponent.hpp
+++ b/include/openPMD/backend/MeshRecordComponent.hpp
@@ -21,6 +21,8 @@
 #pragma once
 
 #include "openPMD/RecordComponent.hpp"
+#include "openPMD/backend/HierarchyVisitor.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <vector>
 
@@ -40,6 +42,7 @@ class MeshRecordComponent : public RecordComponent
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
+    friend class internal::ScientificDefaults;
 
     friend class Mesh;
 
@@ -91,6 +94,12 @@ class MeshRecordComponent : public RecordComponent
      */
     template <typename T>
     MeshRecordComponent &makeConstant(T);
+
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 };
 
 template <typename T>
diff --git a/include/openPMD/backend/PatchRecord.hpp b/include/openPMD/backend/PatchRecord.hpp
index 86317745b8..49a6f1448d 100644
--- a/include/openPMD/backend/PatchRecord.hpp
+++ b/include/openPMD/backend/PatchRecord.hpp
@@ -22,9 +22,9 @@
 
 #include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <string>
-#include <unordered_map>
 
 namespace openPMD
 {
@@ -33,11 +33,15 @@ class PatchRecord : public BaseRecord<PatchRecordComponent>
     friend class Container<PatchRecord>;
     friend class ParticleSpecies;
     friend class ParticlePatches;
+    friend class internal::ScientificDefaults;
 
 public:
-    PatchRecord &setUnitDimension(std::map<UnitDimension, double> const &);
+    PatchRecord &setUnitDimension(unit_representations::AsMap const &);
+    PatchRecord &setUnitDimension(unit_representations::AsArray const &udim);
     ~PatchRecord() override = default;
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
 private:
     PatchRecord() = default;
 
diff --git a/include/openPMD/backend/PatchRecordComponent.hpp b/include/openPMD/backend/PatchRecordComponent.hpp
index eedd84e158..b99de6d266 100644
--- a/include/openPMD/backend/PatchRecordComponent.hpp
+++ b/include/openPMD/backend/PatchRecordComponent.hpp
@@ -24,6 +24,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/auxiliary/ShareRawInternal.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <memory>
 #include <sstream>
@@ -53,6 +54,7 @@ class PatchRecordComponent : public RecordComponent
     friend class ParticlePatches;
     friend class PatchRecord;
     friend class ParticleSpecies;
+    friend class internal::ScientificDefaults;
 
 public:
     /**
@@ -87,18 +89,28 @@ class PatchRecordComponent : public RecordComponent
     template <typename T>
     void store(T);
 
+    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
+
     // clang-format off
 OPENPMD_private
     // clang-format on
 
     using RecordComponent::flush;
 
+    // This differs from RecordComponent::read() such that unitSI is not
+    // required
+    void read();
+
     // clang-format off
 OPENPMD_protected
     // clang-format on
 
     PatchRecordComponent();
     PatchRecordComponent(NoInit);
+
+protected:
+    void scientificDefaults_impl(
+        internal::WriteOrRead, OpenpmdStandard) override;
 }; // PatchRecordComponent
 
 template <typename T>
diff --git a/include/openPMD/backend/PerIterationData.hpp b/include/openPMD/backend/PerIterationData.hpp
new file mode 100644
index 0000000000..6cea297bf2
--- /dev/null
+++ b/include/openPMD/backend/PerIterationData.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "openPMD/ChunkInfo.hpp"
+#include "openPMD/Streaming.hpp"
+#include "openPMD/backend/Attributable.hpp"
+
+#include <variant>
+
+namespace openPMD::internal
+{
+struct NoSourceSpecified
+{};
+struct SourceSpecifiedViaJSON
+{
+    std::string value;
+};
+struct SourceSpecifiedManually
+{
+    std::string value;
+};
+
+struct RankTableData
+{
+    Attributable m_attributable;
+    std::variant<
+        NoSourceSpecified,
+        SourceSpecifiedViaJSON,
+        SourceSpecifiedManually>
+        m_rankTableSource;
+    std::optional<chunk_assignment::RankMeta> m_bufferedRead;
+};
+
+/*
+ * This stores data items that are:
+ *
+ * 1. global in group and variable encodings
+ * 2. per-iteration in file encoding
+ *
+ * The struct is stored as part of the Series and as part of each Iteration.
+ * Access must be distinguished by iteration encoding.
+ */
+struct PerIterationData
+{
+    /**
+     *  Whether a step is currently active for this iteration.
+     * Used for group-based iteration layout, see SeriesData.hpp for
+     * iteration-based layout.
+     * Access via stepStatus() method to automatically select the correct
+     * one among both flags.
+     */
+    StepStatus m_stepStatus = StepStatus::NoStep;
+    Attributable m_rankTableAttributable;
+};
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/Writable.hpp b/include/openPMD/backend/Writable.hpp
index 0396aa1f93..7c04f5f6aa 100644
--- a/include/openPMD/backend/Writable.hpp
+++ b/include/openPMD/backend/Writable.hpp
@@ -46,11 +46,18 @@ template <typename>
 class Span;
 class Series;
 
+namespace traits
+{
+    template <typename T>
+    struct GenerationPolicy;
+} // namespace traits
+
 namespace internal
 {
     class SharedAttributableData;
     class AttributableData;
     class SeriesData;
+    class ScientificDefaults;
 } // namespace internal
 namespace detail
 {
@@ -62,6 +69,14 @@ namespace debug
     void printDirty(Series const &);
 }
 
+enum class ObjectType : std::uint8_t
+{
+    Group,
+    Dataset
+    // Attributes do not get their own objects but are attached to their
+    // respective group or dataset
+};
+
 /** @brief Layer to mirror structure of logical data and persistent data in
  * file.
  *
@@ -106,6 +121,10 @@ class Writable final
     friend void debug::printDirty(Series const &);
     friend struct Parameter<Operation::CREATE_DATASET>;
     friend struct Parameter<Operation::OPEN_DATASET>;
+    friend class internal::ScientificDefaults;
+    friend class CustomHierarchy;
+    template <typename T>
+    friend struct traits::GenerationPolicy;
 
 private:
     Writable(internal::AttributableData *);
@@ -126,14 +145,15 @@ class Writable final
      * it.
      */
     template <bool flush_entire_series>
-    void seriesFlush(std::string backendConfig = "{}");
+    void
+    seriesFlush(std::string backendConfig = "{}", bool flush_io_handler = true);
 
     // clang-format off
 OPENPMD_private
     // clang-format on
 
     template <bool flush_entire_series>
-    void seriesFlush(internal::FlushParams const &);
+    void seriesFlush(internal::FlushParams const &, bool flush_io_handler);
     /*
      * These members need to be shared pointers since distinct instances of
      * Writable may share them.
@@ -152,6 +172,7 @@ OPENPMD_private
      * If multiple Attributables share the same Writable, then the creating one.
      * (See SharedAttributableData)
      */
+    // TODO turn this into a weak pointer
     internal::AttributableData *attributable = nullptr;
     Writable *parent = nullptr;
 
@@ -194,5 +215,7 @@ OPENPMD_private
      *
      */
     bool written = false;
+
+    ObjectType objectType = ObjectType::Group;
 };
 } // namespace openPMD
diff --git a/include/openPMD/backend/scientific_defaults/AttributeReader.hpp b/include/openPMD/backend/scientific_defaults/AttributeReader.hpp
new file mode 100644
index 0000000000..1ca3bcaee1
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/AttributeReader.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "openPMD/Error.hpp"
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp"
+
+#include <deque>
+#include <optional>
+#include <variant>
+
+namespace openPMD::internal
+{
+namespace attribute_read_result
+{
+    struct TypeUnmatched
+    {
+        std::deque<Datatype> expectedDatatypes;
+    };
+    struct Success
+    {};
+} // namespace attribute_read_result
+
+using AttributeReadResult = std::variant<
+    attribute_read_result::Success,
+    attribute_read_result::TypeUnmatched,
+    error::ReadError>;
+
+/*
+ * Struct that describes parsing logic for a standard-defined attribute.
+ * Created by ConfigAttribute::withReader().
+ */
+struct AttributeReader
+{
+    // List of Datatypes accepted for this attribute
+    std::deque<Datatype> eligibleDatatypes;
+    // Optional postprocessing for custom logic of the form:
+    //
+    // (Attributable&, char const *name, Attribute const&)
+    //     -> optional<ReadError>
+    std::optional<std::shared_ptr<ProcessParsedAttribute>> processAttribute;
+
+    AttributeReader(
+        std::deque<Datatype> eligibleDatatypes_in,
+        std::optional<std::shared_ptr<ProcessParsedAttribute>>
+            processAttribute_in);
+
+    auto operator()(
+        Attributable &record,
+        char const *attrName,
+        Attribute const &a,
+        std::deque<Datatype> unmatched_so_far) -> AttributeReadResult;
+};
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/scientific_defaults/ConfigAttribute.hpp b/include/openPMD/backend/scientific_defaults/ConfigAttribute.hpp
new file mode 100644
index 0000000000..63fe17f447
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ConfigAttribute.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/scientific_defaults/AttributeReader.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
+
+#include <deque>
+#include <optional>
+
+namespace openPMD::internal
+{
+/*
+ * Configures parsing and writing (default values) logic for standard-defined
+ * attributes. Created by ScientificDefaults::defaultAttribute(). To be used in
+ * implementations of ScientificDefaults::scientificDefaults_impl().
+ */
+struct ConfigAttribute
+{
+    Attributable &attributable;
+    char const *attrName;
+    std::optional<std::function<void(Attributable &)>> initDefaultAttribute;
+    // Processed "from left to right".
+    // The first reader with a matching datatype is selected. If a ReadError
+    // happens, no further readers will be attempted.
+    std::deque<AttributeReader> attributeReaders;
+
+    template <typename RecordType, typename ValueType>
+    using set_default_val_t = RecordType &(RecordType::*)(ValueType);
+
+    ConfigAttribute(Attributable &attributable_in, char const *attrName_in);
+
+    ConfigAttribute(ConfigAttribute const &) = delete;
+    ConfigAttribute(ConfigAttribute &&) = delete;
+
+    ConfigAttribute &operator=(ConfigAttribute const &) = delete;
+    ConfigAttribute &operator=(ConfigAttribute &&) = delete;
+
+    // Specify a custom function for setting the default attribute,
+    // instead of just using setAttribute().
+    template <typename RecordType, typename S = void, typename GetDefaultValue>
+    [[nodiscard]] auto withSetter(
+        GetDefaultValue &&getDefaultVal,
+        set_default_val_t<
+            RecordType,
+            std::conditional_t<
+                std::is_void_v<S>,
+                auxiliary::CallResult_t<GetDefaultValue>,
+                S>> setDefaultVal) -> ConfigAttribute &;
+
+    // Generically use setAttribute() for initializing
+    template <typename DefaultValue>
+    [[nodiscard]] auto withGenericSetter(DefaultValue &&defaultVal)
+        -> ConfigAttribute &;
+
+    // Add readers for attribute parsing
+    [[nodiscard]] auto withReader(
+        std::deque<Datatype> eligibleDatatypes,
+        std::optional<std::shared_ptr<ProcessParsedAttribute>>
+            processAttribute = std::nullopt) -> ConfigAttribute &;
+
+    void write();
+    void read();
+    void operator()(WriteOrRead wor);
+};
+
+auto get_float_types() -> std::deque<Datatype>;
+auto get_int_types() -> std::deque<Datatype>;
+auto get_numerical_types() -> std::deque<Datatype>;
+auto get_string_types() -> std::deque<Datatype>;
+} // namespace openPMD::internal
+
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.tpp"
diff --git a/include/openPMD/backend/scientific_defaults/ConfigAttribute.tpp b/include/openPMD/backend/scientific_defaults/ConfigAttribute.tpp
new file mode 100644
index 0000000000..70c15c2f35
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ConfigAttribute.tpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+
+namespace openPMD::internal
+{
+namespace
+{
+    // Need SFINAE for this since MSVC doesnt understand if constexpr
+    template <typename GetDefaultValue, typename SFINAE = void>
+    struct CallGetDefaultValue
+    {
+        GetDefaultValue val;
+        CallGetDefaultValue(GetDefaultValue val_in) : val(std::move(val_in))
+        {}
+        auto operator()() && -> GetDefaultValue
+        {
+            return std::move(val);
+        }
+    };
+
+    template <typename GetDefaultValue>
+    struct CallGetDefaultValue<
+        GetDefaultValue,
+        std::void_t<std::invoke_result_t<GetDefaultValue>>>
+    {
+        GetDefaultValue val;
+        CallGetDefaultValue(GetDefaultValue val_in) : val(std::move(val_in))
+        {}
+        auto operator()() && -> std::invoke_result_t<GetDefaultValue>
+        {
+            return std::move(val)();
+        }
+    };
+} // namespace
+
+template <typename RecordType, typename S, typename GetDefaultValue>
+auto ConfigAttribute::withSetter(
+    GetDefaultValue &&getDefaultVal,
+    set_default_val_t<
+        RecordType,
+        std::conditional_t<
+            std::is_void_v<S>,
+            auxiliary::CallResult_t<GetDefaultValue>,
+            S>> setDefaultVal) -> ConfigAttribute &
+{
+    initDefaultAttribute =
+        [callDefaultValue =
+             CallGetDefaultValue<std::remove_reference_t<GetDefaultValue>>(
+                 std::forward<GetDefaultValue>(getDefaultVal)),
+         setDefaultVal](Attributable &attr) mutable {
+            RecordType *record = dynamic_cast<RecordType *>(&attr);
+            if (!record)
+            {
+                throw error::Internal("dynamic cast failure");
+            }
+            ((*record).*setDefaultVal)(std::move(callDefaultValue)());
+        };
+    return *this;
+}
+
+template <typename DefaultValue>
+auto ConfigAttribute::withGenericSetter(DefaultValue &&defaultVal)
+    -> ConfigAttribute &
+{
+    initDefaultAttribute =
+        [this, defaultVal_lambda = std::forward<DefaultValue &&>(defaultVal)](
+            Attributable &attr) {
+            attr.setAttribute(this->attrName, std::move(defaultVal_lambda));
+        };
+    return *this;
+}
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp b/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp
new file mode 100644
index 0000000000..26f467eda0
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp
@@ -0,0 +1,156 @@
+#pragma once
+
+#include "openPMD/Error.hpp"
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/Attribute.hpp"
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+
+namespace openPMD
+{
+class Mesh;
+}
+
+namespace openPMD::internal
+{
+/*
+ * General interface for custom attribute parsing used in struct
+ * AttributeReader. Is applied after the attribute has already been checked
+ * against a list of eligible datatypes.
+ *
+ * The rest of the files contains various implementations.
+ */
+struct ProcessParsedAttribute
+{
+    virtual auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> = 0;
+    virtual ~ProcessParsedAttribute() = default;
+};
+
+//////////////////////////////////////////////////////////
+// 1st implementation: RequireType and associated types //
+//////////////////////////////////////////////////////////
+
+/*
+ * Use for optional postprocessing in RequireType, after the type has been
+ * determined. Poor-man's lambda, in an attempt at reducing use of template
+ * types. The only implementation at PostProcessConvertedAttributeImpl<T> is
+ * conceptually equivalent to storing an object of type RecordType in the lambda
+ * capture.
+ */
+template <typename T>
+struct PostProcessConvertedAttribute
+{
+    virtual auto operator()(T val) -> std::optional<error::ReadError> = 0;
+    virtual ~PostProcessConvertedAttribute() = default;
+};
+
+/*
+ * Defer validation to a function pointer of type handler_t.
+ */
+template <typename T, typename RecordType>
+struct PostProcessConvertedAttributeImpl : PostProcessConvertedAttribute<T>
+{
+    RecordType record;
+    using handler_t = std::optional<error::ReadError> (*)(RecordType &, T);
+    handler_t reader;
+
+    // Use makePostProcessConvertedAttribute below for better type inference
+    PostProcessConvertedAttributeImpl(
+        RecordType record_in, handler_t reader_in);
+    auto operator()(T val) -> std::optional<error::ReadError> override;
+};
+
+// Postprocessing handlers for `handler_t reader` above.
+auto setMeshGeometryFromString(Mesh &mesh, std::string val)
+    -> std::optional<error::ReadError>;
+auto setMeshDataOrderFromChar(Mesh &mesh, char val)
+    -> std::optional<error::ReadError>;
+
+template <typename T, typename RecordType>
+auto makePostProcessConvertedAttribute(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<PostProcessConvertedAttribute<T>>;
+/*
+ * Validate an attribute by requiring one specific type T, and by optionally
+ * postprocessing it. Type conversions for the attribute are attempted.
+ * Note that type checking for attribute is mainly intended to by done by
+ * specifying eligible data types in struct AttributeReader. This handler's
+ * purpose is dynamically casting to one specific type not required by the
+ * standard, but by our further handling (e.g. setMeshGeometryFromString above
+ * requires a string, but we should also accept single chars, or vectors with a
+ * single element if we we find such things on disk).
+ * If a handler is not specified, this just casts the type and then uses
+ * setAttribute().
+ */
+template <typename T>
+struct RequireType : ProcessParsedAttribute
+{
+    std::optional<std::shared_ptr<PostProcessConvertedAttribute<T>>>
+        postProcess;
+
+    explicit RequireType() = default;
+
+    // Use require_type() helpers below for construction.
+    template <typename RecordType>
+    RequireType(
+        RecordType &&record,
+        std::optional<error::ReadError> (*handler)(
+            std::remove_reference_t<RecordType> &, T));
+
+    auto operator()(
+        Attributable &record, char const *attrName, Attribute const &attr)
+        -> std::optional<error::ReadError> override;
+};
+
+template <typename T, typename RecordType>
+auto require_type(
+    RecordType &&record,
+    std::optional<error::ReadError> (*)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<ProcessParsedAttribute>;
+// common case: directly use setAttribute
+template <typename T>
+auto require_type() -> std::shared_ptr<ProcessParsedAttribute>;
+
+///////////////////////////////////////
+// 2nd implementation: RequireVector //
+///////////////////////////////////////
+
+/*
+ * Validate an attribute by requiring a vector type, potentially wrapping
+ * scalar values into a vector.
+ * Note that this employs no type checking for the base type, this is done
+ * by the type list argument of ConfigAttribute::withReader().
+ */
+struct RequireVector : ProcessParsedAttribute
+{
+    auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> override;
+};
+extern std::shared_ptr<ProcessParsedAttribute> require_vector;
+
+///////////////////////////////////////
+// 3rd implementation: RequireScalar //
+///////////////////////////////////////
+
+/*
+ * Validate an attribute by requiring a scalar type, potentially unwrapping
+ * single values from a vector.
+ * Note that this employs no type checking for the base type, this is done
+ * by the type list argument of ConfigAttribute::withReader().
+ */
+struct RequireScalar : ProcessParsedAttribute
+{
+    auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> override;
+};
+extern std::shared_ptr<ProcessParsedAttribute> require_scalar;
+} // namespace openPMD::internal
+
+#include "openPMD/backend/scientific_defaults/ProcessParsedAttribute.tpp"
diff --git a/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.tpp b/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.tpp
new file mode 100644
index 0000000000..f398fd3a86
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ProcessParsedAttribute.tpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include "openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp"
+
+#include <variant>
+
+namespace openPMD::internal
+{
+template <typename T, typename RecordType>
+PostProcessConvertedAttributeImpl<T, RecordType>::
+    PostProcessConvertedAttributeImpl(RecordType record_in, handler_t reader_in)
+    : record(std::move(record_in)), reader(reader_in)
+{}
+
+template <typename T, typename RecordType>
+auto PostProcessConvertedAttributeImpl<T, RecordType>::operator()(T val)
+    -> std::optional<error::ReadError>
+{
+    return (*reader)(record, std::move(val));
+}
+
+template <typename T, typename RecordType>
+auto require_type(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<ProcessParsedAttribute>
+{
+    return std::make_shared<RequireType<T>>(
+        std::forward<RecordType>(record), handler);
+}
+
+template <typename T>
+auto require_type() -> std::shared_ptr<ProcessParsedAttribute>
+{
+    return std::make_shared<RequireType<T>>();
+}
+
+template <typename T, typename RecordType>
+auto makePostProcessConvertedAttribute(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<PostProcessConvertedAttribute<T>>
+{
+    return std::make_shared<PostProcessConvertedAttributeImpl<
+        T,
+        std::remove_reference_t<RecordType>>>(
+        std::forward<RecordType>(record), handler);
+}
+
+template <typename T>
+template <typename RecordType>
+RequireType<T>::RequireType(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    : postProcess(makePostProcessConvertedAttribute(
+          std::forward<RecordType>(record), handler))
+{}
+
+template <typename T>
+auto RequireType<T>::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto converted_or_error = attr.getOrError<T>();
+    return std::visit(
+        auxiliary::overloaded{
+            [&](T casted_val) -> std::optional<error::ReadError> {
+                if (this->postProcess.has_value())
+                {
+                    return (**this->postProcess)(std::move(casted_val));
+                }
+                else
+                {
+                    record.setAttribute<T>(attrName, std::move(casted_val));
+                    return std::nullopt;
+                }
+            },
+            [](std::runtime_error const &err)
+                -> std::optional<error::ReadError> {
+                std::string msg = "Expected specific type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            }},
+        converted_or_error);
+}
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/scientific_defaults/ScientificDefaults.hpp b/include/openPMD/backend/scientific_defaults/ScientificDefaults.hpp
new file mode 100644
index 0000000000..c334151147
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ScientificDefaults.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
+
+namespace openPMD
+{
+class Attributable;
+}
+
+namespace openPMD::internal
+{
+/*
+ * This is the interface for implementing required scientific attributes defined
+ * by the openPMD standard (writing and reading). The interface is inherited by
+ * classes in the openPMD hierarchy object model (e.g. Iteration,
+ * ParticleSpecies, ...). This is the place for implementing (most of) the
+ * attribute definitions from
+ * github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md
+ */
+class ScientificDefaults
+{
+    friend class ::openPMD::Attributable;
+
+protected:
+    [[nodiscard]] auto defaultAttribute(Attributable &, char const *attrName)
+        -> ConfigAttribute;
+
+    // Convention: This is called for each openPMD object (group, dataset)
+    // exactly once and only upon its most derived object (e.g. upon
+    // RecordComponent, not BaseRecordComponent). The defaults_impl() definition
+    // has to deal with parent class definitions. This is necessary since the
+    // derived class may override standard attribute definitions from a base
+    // class.
+    //
+    // Used both by writeDefaults() and readDefaults().
+    //
+    // Use defaultAttribute() for creating an attribute, use helpers inside
+    // ConfigAttribute for defining it.
+    virtual void
+        scientificDefaults_impl(internal::WriteOrRead, OpenpmdStandard) = 0;
+
+    // Called upon Iteration::close(), will fill in defaults below Iteration
+    // level. If the Iteration is not explicitly closed, will be called upon
+    // Series::close().
+    // Currently called internally only from Iteration::setDefaultsAttributes().
+    void writeDefaults(OpenpmdStandard);
+
+    // Called at appropriate places during parsing.
+    void readDefaults(Attributable &, OpenpmdStandard);
+};
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp b/include/openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp
new file mode 100644
index 0000000000..84413dadc0
--- /dev/null
+++ b/include/openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "openPMD/backend/Attribute.hpp"
+
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace openPMD::auxiliary
+{
+template <typename F, typename SFINAE = void>
+struct CallResult
+{
+    // If F is not callable, then use its type directly without calling.
+    using type = F;
+};
+
+template <typename F>
+struct CallResult<F, std::void_t<decltype(std::declval<F>()())>>
+{
+    // If F is callable (used to avoid complex computations until necessary),
+    // then use its return type.
+    using type = decltype(std::declval<F>()());
+};
+
+template <typename F>
+using CallResult_t = typename CallResult<F>::type;
+
+template <typename T>
+auto write_val_to_stderr(T const &val) -> std::ostream &;
+auto write_to_stderr(Attribute const &a) -> std::ostream &;
+
+auto createDefaultAxisLabels(uint64_t dimensionality)
+    -> std::vector<std::string>;
+auto createDefaultVector(uint64_t dimensionality, double defaultValue)
+    -> std::vector<double>;
+} // namespace openPMD::auxiliary
+
+namespace openPMD::internal
+{
+enum class WriteOrRead : std::uint8_t
+{
+    Write,
+    Read
+};
+}
diff --git a/include/openPMD/openPMD.hpp b/include/openPMD/openPMD.hpp
index 083a1e3342..e5da821699 100644
--- a/include/openPMD/openPMD.hpp
+++ b/include/openPMD/openPMD.hpp
@@ -26,6 +26,7 @@ namespace openPMD
 {}
 
 // IWYU pragma: begin_exports
+#include "openPMD/CustomHierarchy.hpp"
 #include "openPMD/Dataset.hpp"
 #include "openPMD/Datatype.hpp"
 #include "openPMD/Error.hpp"
@@ -45,6 +46,7 @@ namespace openPMD
 #include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitorImpl.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/PatchRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
diff --git a/include/openPMD/snapshots/ContainerImpls.hpp b/include/openPMD/snapshots/ContainerImpls.hpp
index f41e88c697..dda04d77fb 100644
--- a/include/openPMD/snapshots/ContainerImpls.hpp
+++ b/include/openPMD/snapshots/ContainerImpls.hpp
@@ -131,9 +131,9 @@ class RandomAccessIteratorContainer : public AbstractSnapshotsContainer
 {
 private:
     friend class Series;
-    using Container_t = Container<Iteration, key_type>;
+    using Container_t = Iterations;
     Container_t m_cont;
-    RandomAccessIteratorContainer(Container<Iteration, key_type> cont);
+    RandomAccessIteratorContainer(Iterations cont);
 
     using concrete_iterator_type = RandomAccessIterator<Container_t::iterator>;
     using concrete_reverse_iterator_type =
diff --git a/src/CustomHierarchy.cpp b/src/CustomHierarchy.cpp
new file mode 100644
index 0000000000..3f4a7634ef
--- /dev/null
+++ b/src/CustomHierarchy.cpp
@@ -0,0 +1,943 @@
+/* Copyright 2023 Franz Poeschel
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "openPMD/CustomHierarchy.hpp"
+#include "openPMD/auxiliary/Defer.hpp"
+#include "openPMD/backend/Container.hpp"
+
+namespace openPMD
+{
+namespace traits
+{
+    template <typename Container_const_or_not>
+    void DeferredInitPolicy<Container<CustomHierarchy>>::call(
+        Container_const_or_not &container)
+    {
+        // Need to sync backend objects into the CustomHierarchy instance
+        // Need to be a bit sneaky, we must modify my_container&, but this
+        // method might be called as const. shared_ptr<>s implement interior
+        // mutability, so use that here.
+
+        // auto &container_front = container.container_front();
+        auto &container_front = container.m_containerData->m_container;
+        auto &container_back = container.container_back(/* verify = */ false);
+
+        auto size_front = container_front.size();
+        auto size_back = container_back.size();
+
+        if (size_front == size_back)
+        {
+            return;
+        }
+        else if (size_front > size_back)
+        {
+            std::stringstream error;
+            auto print = [&error](auto const &map) -> std::stringstream & {
+                if (map.empty())
+                {
+                    error << "[]";
+                }
+                else
+                {
+                    error << '[';
+                    auto it = map.begin();
+                    error << (it++)->first;
+                    auto end = map.end();
+                    for (; it != end; ++it)
+                    {
+                        error << ", " << it->first;
+                    }
+                    error << ']';
+                }
+                return error;
+            };
+            error << "CustomHierarchy went into illegal state at '"
+                  << container.myPath().openPMDPath()
+                  << "':\nfront container: ";
+            print(container_front) << "\nback container:  ";
+            print(container_back) << '\n';
+            throw error::Internal(error.str());
+        }
+
+        GenerationPolicy<CustomHierarchy> gen;
+
+        auto it = container_front.begin();
+        auto end = container_front.end();
+        for (auto const &[key, attributable] : container_back)
+        {
+            if (it == end || it->first != key)
+            {
+                // under the invariant that the front container contains no
+                // elements that are not present in the back container, it now
+                // points to an entry past the to-be-inserted key
+                it = container_front.emplace_hint(
+                    it, key, CustomHierarchy(attributable));
+                gen(container, it);
+            }
+        }
+    }
+    template void DeferredInitPolicy<Container<CustomHierarchy>>::call(
+        Container<CustomHierarchy> &);
+    template void DeferredInitPolicy<Container<CustomHierarchy>>::call(
+        Container<CustomHierarchy> const &);
+} // namespace traits
+CustomHierarchy::CustomHierarchy() : ConvertibleContainer(NoInit{})
+{
+    setData(std::make_shared<Data_t>());
+}
+
+CustomHierarchy::CustomHierarchy(NoInit) : ConvertibleContainer(NoInit{})
+{}
+
+CustomHierarchy::CustomHierarchy(
+    std::shared_ptr<internal::SharedAttributableData> other)
+    : ConvertibleContainer(NoInit{})
+{
+    auto data = std::make_shared<Data_t>();
+    data->asSharedPtrOfAttributable() = std::move(other);
+    setData(std::move(data));
+}
+
+CustomHierarchy::CustomHierarchy(Attributable const &other)
+    : CustomHierarchy(other.m_attri->asSharedPtrOfAttributable())
+{}
+
+void CustomHierarchy::read(size_t const max_recursion_depth)
+{
+    auxiliary::opaque_defer_type reset_parsing_status;
+    if (IOHandler()->m_seriesStatus != internal::SeriesStatus::Parsing)
+    {
+        IOHandler()->m_seriesStatus = internal::SeriesStatus::Parsing;
+        reset_parsing_status = auxiliary::defer([&]() {
+            IOHandler()->m_seriesStatus = internal::SeriesStatus::Default;
+        });
+    }
+    if (!writable().written)
+    {
+        auto do_throw = [&]() {
+            throw error::WrongAPIUsage(
+                "Cannot read contents of CustomHierarchy path '" +
+                myPath().openPMDPath() +
+                "', since the backend does not yet / no longer know about this "
+                "object. Ensure that the object is open (e.g. by opening its "
+                "containing Iteration or by reading parent paths first)");
+        };
+        auto parent = writable().parent;
+        if (!parent)
+        {
+            do_throw();
+        }
+        Attributable parent_attributable(NoInit{});
+        parent_attributable.setData(
+            std::shared_ptr<internal::AttributableData>{
+                parent->attributable, [](auto const *) {}});
+        CustomHierarchy parent_(parent_attributable);
+        parent_.read(1);
+        if (!writable() /* still not */.written)
+        {
+            do_throw();
+        }
+    }
+    /*
+     * Convention for CustomHierarchy::flush and CustomHierarchy::read:
+     * Path is created/opened already at entry point of method, method needs
+     * to create/open path for contained subpaths.
+     */
+
+    Attributable::readAttributes(ReadMode::FullyReread);
+
+    switch (writable().objectType)
+    {
+    case ObjectType::Group:
+        break;
+    case ObjectType::Dataset:
+        return;
+    }
+
+    auto do_recurse = [this, max_recursion_depth](CustomHierarchy &child) {
+        switch (max_recursion_depth)
+        {
+        case 0:
+            IOHandler()->flush(internal::defaultFlushParams);
+            child.read(0);
+            break;
+        case 1:
+            break;
+        default:
+            IOHandler()->flush(internal::defaultFlushParams);
+            child.read(max_recursion_depth - 1);
+            break;
+        }
+    };
+
+    Parameter<Operation::LIST_PATHS> pList;
+    IOHandler()->enqueue(IOTask(this, pList));
+
+    Parameter<Operation::LIST_DATASETS> dList;
+    IOHandler()->enqueue(IOTask(this, dList));
+
+    IOHandler()->flush(internal::defaultFlushParams);
+
+    auto &container_back_ = container_back(/* verify = */ true);
+    for (auto const &path : *pList.paths)
+    {
+        if (auto it = container_back_.find(path);
+            it != container_back_.end() && it->second->m_writable.written)
+        {
+            // Is already known
+            continue;
+        }
+        Parameter<Operation::OPEN_PATH> pOpen;
+        pOpen.path = path;
+        auto &subpath = this->operator[](path);
+        subpath.linkHierarchy(this->writable());
+        IOHandler()->enqueue(IOTask(&subpath, pOpen));
+        do_recurse(subpath);
+    }
+
+    for (auto const &path : *dList.datasets)
+    {
+        if (auto it = container_back_.find(path);
+            it != container_back_.end() && it->second->m_writable.written)
+        {
+            // Is already known
+            continue;
+        }
+        Parameter<Operation::OPEN_DATASET> dOpen;
+        dOpen.name = path;
+
+        auto &subpath = this->operator[](path);
+        subpath.linkHierarchy(this->writable());
+        IOHandler()->enqueue(IOTask(&subpath, dOpen));
+        do_recurse(subpath);
+    }
+
+    setDirty(false);
+    IOHandler()->flush(internal::defaultFlushParams);
+}
+
+void CustomHierarchy::flush(
+    std::string const & /* path */, internal::FlushParams const &)
+{
+    throw std::runtime_error("Use Attributable::customHierarchyFlush instead!");
+}
+
+void CustomHierarchy::linkHierarchy(Writable &w)
+{
+    Attributable::linkHierarchy(w);
+}
+
+void CustomHierarchy::printRecursively()
+{
+    std::cout << &writable() << " [" << dirty() << "," << dirtyRecursive()
+              << "]  ";
+    if (empty())
+    {
+        std::cout << "<EMPTY>\n";
+        return;
+    }
+    else
+    {
+        std::cout << writable().ownKeyWithinParent << '\n';
+        printRecursively("");
+        std::cout.flush();
+    }
+}
+
+void CustomHierarchy::printRecursively(std::string indent)
+{
+    auto print_indent = [&indent]() { std::cout << indent; };
+    auto it = begin();
+    auto end_ = end();
+    if (it == end_)
+    {
+        return;
+    }
+    auto prev = it;
+    ++it;
+    auto next_indent = indent + "│ ";
+    for (; it != end_; prev = it, ++it)
+    {
+        std::cout << &prev->second.writable() << " [" << prev->second.dirty()
+                  << "," << prev->second.dirtyRecursive() << "]  ";
+        print_indent();
+        std::cout << "├─" << prev->first << '\n';
+        prev->second.printRecursively(next_indent);
+    }
+    std::cout << &prev->second.writable() << " [" << prev->second.dirty() << ","
+              << prev->second.dirtyRecursive() << "]  ";
+    print_indent();
+    std::cout << "└─" << prev->first << '\n';
+    prev->second.printRecursively(indent + "  ");
+}
+} // namespace openPMD
+
+#if 0
+#include "openPMD/Dataset.hpp"
+#include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/Access.hpp"
+#include "openPMD/IO/IOTask.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/RecordComponent.hpp"
+#include "openPMD/Series.hpp"
+#include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/Writable.hpp"
+
+#include <algorithm>
+#include <deque>
+#include <initializer_list>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <optional>
+#include <regex>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <variant>
+
+// @todo add handselected choice of [:punct:] characters to this
+// using a macro here to make string interpolation simpler
+#define OPENPMD_LEGAL_IDENTIFIER_CHARS "[:alnum:]_"
+#define OPENPMD_SINGLE_GLOBBING_CHAR "%"
+#define OPENPMD_DOUBLE_GLOBBING_CHAR "%%"
+
+namespace
+{
+template <typename Iterator>
+std::string
+concatWithSep(Iterator &&begin, Iterator const &end, std::string const &sep)
+{
+    if (begin == end)
+    {
+        return "";
+    }
+    std::stringstream res;
+    res << *(begin++);
+    for (; begin != end; ++begin)
+    {
+        res << sep << *begin;
+    }
+    return res.str();
+}
+
+std::string
+concatWithSep(std::vector<std::string> const &v, std::string const &sep)
+{
+    return concatWithSep(v.begin(), v.end(), sep);
+}
+
+// Not specifying std::regex_constants::optimize here, only using it where
+// it makes sense to.
+constexpr std::regex_constants::syntax_option_type regex_flags =
+    std::regex_constants::egrep;
+
+template <typename OutParam>
+void setDefaultMeshesParticlesPath(
+    std::vector<std::string> const &meshes,
+    std::vector<std::string> const &particles,
+    OutParam &writeTarget)
+{
+    std::regex is_default_path_specification(
+        "[" OPENPMD_LEGAL_IDENTIFIER_CHARS "]+/",
+        regex_flags | std::regex_constants::optimize);
+    constexpr char const *default_default_mesh = "meshes";
+    constexpr char const *default_default_particle = "particles";
+    for (auto [vec, defaultPath, default_default] :
+         {std::make_tuple(
+              &meshes, &writeTarget.m_defaultMeshesPath, default_default_mesh),
+          std::make_tuple(
+              &particles,
+              &writeTarget.m_defaultParticlesPath,
+              default_default_particle)})
+    {
+        bool set_default = true;
+        /*
+         * The first eligible path in meshesPath/particlesPath is used as
+         * the default, "meshes"/"particles" otherwise.
+         */
+        for (auto const &path : *vec)
+        {
+            if (std::regex_match(path, is_default_path_specification))
+            {
+                *defaultPath = openPMD::auxiliary::replace_last(path, "/", "");
+                set_default = false;
+                break;
+            }
+        }
+        if (set_default)
+        {
+            *defaultPath = default_default;
+        }
+    }
+}
+
+bool anyPathRegexMatches(
+    std::regex const &regex, std::vector<std::string> const &path)
+{
+    std::string pathToMatch = '/' + concatWithSep(path, "/") + '/';
+    return std::regex_match(pathToMatch, regex);
+}
+} // namespace
+
+namespace openPMD
+{
+namespace internal
+{
+    namespace
+    {
+        std::string globToRegexLongForm(std::string const &glob)
+        {
+            return auxiliary::replace_all(
+                auxiliary::replace_all(
+                    glob,
+                    OPENPMD_DOUBLE_GLOBBING_CHAR,
+                    "([" OPENPMD_LEGAL_IDENTIFIER_CHARS "/]*)"),
+                OPENPMD_SINGLE_GLOBBING_CHAR,
+                "([" OPENPMD_LEGAL_IDENTIFIER_CHARS "]*)");
+        }
+
+        std::string globToRegexShortForm(std::string const &glob)
+        {
+            return "[" OPENPMD_LEGAL_IDENTIFIER_CHARS "/]*/" + glob;
+        }
+    } // namespace
+
+    MeshesParticlesPath::MeshesParticlesPath(
+        std::vector<std::string> const &meshes,
+        std::vector<std::string> const &particles)
+    {
+        /*
+         * /group/meshes/E is a mesh if the meshes path contains:
+         *
+         * 1) '/group/meshes/' (absolute path to mesh container)
+         * 2) 'meshes/' (relative path to mesh container)
+         *
+         * All this analogously for particles path.
+         */
+
+        // regex for detecting option 1)
+        // e.g. '/path/to/meshes/': The path to the meshes. Mandatory slashes at
+        //                          beginning and end, possibly slashes in
+        //                          between. Mandatory slash at beginning might
+        //                          be replaced with '%%' to enable paths like
+        //                          '%%/path/to/meshes'.
+        // resolves to: `(/|%%)[[:alnum:]_%/]+/`
+        std::regex is_legal_long_path_specification(
+            "(/|" OPENPMD_DOUBLE_GLOBBING_CHAR
+            ")[" OPENPMD_LEGAL_IDENTIFIER_CHARS OPENPMD_SINGLE_GLOBBING_CHAR
+            "/]+/",
+            regex_flags | std::regex_constants::optimize);
+
+        // Regex for detecting option 2)
+        // e.g. 'meshes/': The name without path. One single mandatory slash
+        //                 at the end, no slashes otherwise.
+        // resolves to `[[:alnum:]_]+/`
+        std::regex is_legal_short_path_specification(
+            "[" OPENPMD_LEGAL_IDENTIFIER_CHARS "]+/",
+            regex_flags | std::regex_constants::optimize);
+
+        for (auto [target_regex, vec] :
+             {std::make_tuple(&this->meshRegex, &meshes),
+              std::make_tuple(&this->particleRegex, &particles)})
+        {
+            std::stringstream build_regex;
+            // neutral element: empty language, regex doesn't match anything
+            build_regex << "(a^)";
+            for (auto const &entry : *vec)
+            {
+                if (std::regex_match(entry, is_legal_short_path_specification))
+                {
+                    build_regex << "|(" << globToRegexShortForm(entry) << ')';
+                }
+                else if (std::regex_match(
+                             entry, is_legal_long_path_specification))
+                {
+                    build_regex << "|(" << globToRegexLongForm(entry) << ')';
+                }
+                else
+                {
+                    std::cerr
+                        << "[WARNING] Not a legal meshes-/particles-path: '"
+                        << entry << "'. Will skip." << std::endl;
+                }
+            }
+            auto regex_string = build_regex.str();
+            // std::cout << "Using regex string: " << regex_string << std::endl;
+            *target_regex = std::regex(
+                regex_string, regex_flags | std::regex_constants::optimize);
+        }
+        setDefaultMeshesParticlesPath(meshes, particles, *this);
+    }
+
+    ContainedType MeshesParticlesPath::determineType(
+        std::vector<std::string> const &path) const
+    {
+        if (isMeshContainer(path))
+        {
+            return ContainedType::Mesh;
+        }
+        else if (isParticleContainer(path))
+        {
+            return ContainedType::Particle;
+        }
+        else
+        {
+            return ContainedType::Group;
+        }
+    }
+
+    bool MeshesParticlesPath::isParticleContainer(
+        std::vector<std::string> const &path) const
+    {
+        return anyPathRegexMatches(particleRegex, path);
+    }
+    bool MeshesParticlesPath::isMeshContainer(
+        std::vector<std::string> const &path) const
+    {
+        return anyPathRegexMatches(meshRegex, path);
+    }
+
+    CustomHierarchyData::CustomHierarchyData()
+    {
+        syncAttributables();
+    }
+
+    void CustomHierarchyData::syncAttributables()
+    {
+        /*
+         * m_embeddeddatasets and its friends should point to the same instance
+         * of Attributable.
+         * Not strictly necessary to do this explicitly due to virtual
+         * inheritance (all Attributable instances are the same anyway),
+         * but let's be explicit about this.
+         */
+        for (auto p : std::initializer_list<AttributableData *>{
+                 static_cast<ContainerData<CustomHierarchy> *>(this),
+                 static_cast<ContainerData<RecordComponent> *>(this),
+                 static_cast<ContainerData<Mesh> *>(this),
+                 static_cast<ContainerData<ParticleSpecies> *>(this)})
+        {
+            p->asSharedPtrOfAttributable() = this->asSharedPtrOfAttributable();
+        }
+    }
+} // namespace internal
+
+// template
+// class ConversibleContainer<CustomHierarchy>;
+
+CustomHierarchy::CustomHierarchy() : ConversibleContainer(NoInit{})
+{
+    setData(std::make_shared<Data_t>());
+}
+CustomHierarchy::CustomHierarchy(NoInit) : ConversibleContainer(NoInit{})
+{}
+
+void CustomHierarchy::readNonscalarMesh(
+    EraseStaleMeshes &map, std::string const &mesh_name)
+{
+    Parameter<Operation::OPEN_PATH> pOpen;
+    Parameter<Operation::LIST_ATTS> aList;
+
+    Mesh &m = map[mesh_name];
+
+    pOpen.path = mesh_name;
+    aList.attributes->clear();
+    IOHandler()->enqueue(IOTask(&m, pOpen));
+    IOHandler()->enqueue(IOTask(&m, aList));
+    IOHandler()->flush(internal::defaultFlushParams);
+
+    // Find constant scalar meshes. shape generally required for meshes,
+    // shape also required for scalars.
+    // https://github.com/openPMD/openPMD-standard/pull/289
+    auto att_begin = aList.attributes->begin();
+    auto att_end = aList.attributes->end();
+    auto value = std::find(att_begin, att_end, "value");
+    auto shape = std::find(att_begin, att_end, "shape");
+    if (value != att_end && shape != att_end)
+    {
+        MeshRecordComponent &mrc = m;
+        IOHandler()->enqueue(IOTask(&mrc, pOpen));
+        IOHandler()->flush(internal::defaultFlushParams);
+        mrc.get().m_isConstant = true;
+    }
+    try
+    {
+        m.read();
+    }
+    catch (error::ReadError const &err)
+    {
+        std::cerr << "Cannot read mesh with name '" << mesh_name
+                  << "' and will skip it due to read error:\n"
+                  << err.what() << std::endl;
+        map.forget(mesh_name);
+    }
+}
+
+void CustomHierarchy::readScalarMesh(
+    EraseStaleMeshes &map, std::string const &mesh_name)
+{
+    Parameter<Operation::OPEN_PATH> pOpen;
+    Parameter<Operation::LIST_PATHS> pList;
+
+    Parameter<Operation::OPEN_DATASET> dOpen;
+    Mesh &m = map[mesh_name];
+    dOpen.name = mesh_name;
+    MeshRecordComponent &mrc = m;
+    IOHandler()->enqueue(IOTask(&mrc, dOpen));
+    IOHandler()->flush(internal::defaultFlushParams);
+    mrc.setWritten(false, Attributable::EnqueueAsynchronously::No);
+    mrc.resetDataset(Dataset(*dOpen.dtype, *dOpen.extent));
+    mrc.setWritten(true, Attributable::EnqueueAsynchronously::No);
+    try
+    {
+        m.read();
+    }
+    catch (error::ReadError const &err)
+    {
+        std::cerr << "Cannot read mesh with name '" << mesh_name
+                  << "' and will skip it due to read error:\n"
+                  << err.what() << std::endl;
+        map.forget(mesh_name);
+    }
+}
+
+void CustomHierarchy::readParticleSpecies(
+    EraseStaleParticles &map, std::string const &species_name)
+{
+    Parameter<Operation::OPEN_PATH> pOpen;
+    Parameter<Operation::LIST_PATHS> pList;
+
+    ParticleSpecies &p = map[species_name];
+    pOpen.path = species_name;
+    IOHandler()->enqueue(IOTask(&p, pOpen));
+    IOHandler()->flush(internal::defaultFlushParams);
+    try
+    {
+        p.read();
+    }
+    catch (error::ReadError const &err)
+    {
+        std::cerr << "Cannot read particle species with name '" << species_name
+                  << "' and will skip it due to read error:\n"
+                  << err.what() << std::endl;
+        map.forget(species_name);
+    }
+}
+
+void CustomHierarchy::read(internal::MeshesParticlesPath const &mpp)
+{
+    std::vector<std::string> currentPath;
+    read(mpp, currentPath);
+}
+
+void CustomHierarchy::read(
+    internal::MeshesParticlesPath const &mpp,
+    std::vector<std::string> &currentPath)
+{
+    /*
+     * Convention for CustomHierarchy::flush and CustomHierarchy::read:
+     * Path is created/opened already at entry point of method, method needs
+     * to create/open path for contained subpaths.
+     */
+
+    Parameter<Operation::LIST_PATHS> pList;
+    IOHandler()->enqueue(IOTask(this, pList));
+
+    Attributable::readAttributes(ReadMode::FullyReread);
+    Parameter<Operation::LIST_DATASETS> dList;
+    IOHandler()->enqueue(IOTask(this, dList));
+    IOHandler()->flush(internal::defaultFlushParams);
+
+    std::deque<std::string> constantComponentsPushback;
+    auto &data = get();
+    auto embeddedMeshes = data.embeddedMeshesWrapped();
+    auto embeddedParticles = data.embeddedParticlesWrapped();
+    EraseStaleMeshes meshesMap(embeddedMeshes);
+    EraseStaleParticles particlesMap(embeddedParticles);
+    for (auto const &path : *pList.paths)
+    {
+        switch (mpp.determineType(currentPath))
+        {
+        case internal::ContainedType::Group: {
+            Parameter<Operation::OPEN_PATH> pOpen;
+            pOpen.path = path;
+            auto &subpath = this->operator[](path);
+            IOHandler()->enqueue(IOTask(&subpath, pOpen));
+            currentPath.emplace_back(path);
+            try
+            {
+                subpath.read(mpp, currentPath);
+            }
+            catch (error::ReadError const &err)
+            {
+                std::cerr << "Cannot read subgroup '" << path << "' at path '"
+                          << myPath().openPMDPath()
+                          << "' and will skip it due to read error:\n"
+                          << err.what() << std::endl;
+                container().erase(path);
+            }
+            currentPath.pop_back();
+            if (subpath.size() == 0 && subpath.containsAttribute("shape") &&
+                subpath.containsAttribute("value"))
+            {
+                // This is not a group, but a constant record component
+                // Writable::~Writable() will deal with removing this from the
+                // backend again.
+                constantComponentsPushback.push_back(path);
+                container().erase(path);
+            }
+            break;
+        }
+        case internal::ContainedType::Mesh: {
+            try
+            {
+                readNonscalarMesh(meshesMap, path);
+            }
+            catch (error::ReadError const &err)
+            {
+                std::cerr << "Cannot read mesh at location '"
+                          << myPath().openPMDPath() << "/" << path
+                          << "' and will skip it due to read error:\n"
+                          << err.what() << std::endl;
+                meshesMap.forget(path);
+            }
+            break;
+        }
+        case internal::ContainedType::Particle: {
+            try
+            {
+                readParticleSpecies(particlesMap, path);
+            }
+            catch (error::ReadError const &err)
+            {
+                std::cerr << "Cannot read particle species at location '"
+                          << myPath().openPMDPath() << "/" << path
+                          << "' and will skip it due to read error:\n"
+                          << err.what() << std::endl;
+                particlesMap.forget(path);
+            }
+            break;
+        }
+        }
+    }
+    for (auto const &path : *dList.datasets)
+    {
+        switch (mpp.determineType(currentPath))
+        {
+
+        case internal::ContainedType::Particle:
+            std::cerr << "[Warning] Dataset found at '"
+                      << (concatWithSep(currentPath, "/") + "/" + path)
+                      << "' inside the particles path. A particle species is "
+                         "always a group, never a dataset. Will parse as a "
+                         "custom dataset. Storing custom datasets inside the "
+                         "particles path is discouraged."
+                      << std::endl;
+            [[fallthrough]];
+        // Group is a bit of an internal misnomer here, it just means that
+        // it matches neither meshes nor particles path
+        case internal::ContainedType::Group: {
+            auto embeddedDatasets = data.embeddedDatasetsWrapped();
+            auto &rc = embeddedDatasets[path];
+            Parameter<Operation::OPEN_DATASET> dOpen;
+            dOpen.name = path;
+            IOHandler()->enqueue(IOTask(&rc, dOpen));
+            try
+            {
+                IOHandler()->flush(internal::defaultFlushParams);
+                rc.setWritten(false, Attributable::EnqueueAsynchronously::No);
+                rc.resetDataset(Dataset(*dOpen.dtype, *dOpen.extent));
+                rc.setWritten(true, Attributable::EnqueueAsynchronously::No);
+                rc.read(/* read_defaults = */ false);
+            }
+            catch (error::ReadError const &err)
+            {
+                std::cerr << "Cannot read contained custom dataset '" << path
+                          << "' at path '" << myPath().openPMDPath()
+                          << "' and will skip it due to read error:\n"
+                          << err.what() << std::endl;
+                embeddedDatasets.erase(path);
+            }
+            break;
+        }
+        case internal::ContainedType::Mesh:
+            try
+            {
+                readScalarMesh(meshesMap, path);
+            }
+            catch (error::ReadError const &err)
+            {
+                std::cerr << "Cannot read scalar mesh at location '"
+                          << myPath().openPMDPath() << "/" << path
+                          << "' and will skip it due to read error:\n"
+                          << err.what() << std::endl;
+                meshesMap.forget(path);
+            }
+            break;
+        }
+    }
+
+    for (auto const &path : constantComponentsPushback)
+    {
+        auto embeddedDatasets = data.embeddedDatasetsWrapped();
+        auto &rc = embeddedDatasets[path];
+        try
+        {
+            Parameter<Operation::OPEN_PATH> pOpen;
+            pOpen.path = path;
+            IOHandler()->enqueue(IOTask(&rc, pOpen));
+            rc.get().m_isConstant = true;
+            rc.read(/* read_defaults = */ false);
+        }
+        catch (error::ReadError const &err)
+        {
+            std::cerr << "Cannot read dataset at location '"
+                      << myPath().openPMDPath() << "/" << path
+                      << "' and will skip it due to read error:\n"
+                      << err.what() << std::endl;
+            embeddedDatasets.erase(path);
+        }
+    }
+    setDirty(false);
+}
+
+void CustomHierarchy::flush_internal(
+    internal::FlushParams const &flushParams,
+    internal::MeshesParticlesPath &mpp,
+    std::vector<std::string> currentPath)
+{
+    if (!dirtyRecursive())
+    {
+        return;
+    }
+    /*
+     * Convention for CustomHierarchy::flush and CustomHierarchy::read:
+     * Path is created/opened already at entry point of method, method needs
+     * to create/open path for contained subpaths.
+     */
+
+    // No need to do anything in access::readOnly since meshes and particles
+    // are initialized as aliases for subgroups at parsing time
+    auto &data = get();
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        flushAttributes(flushParams);
+    }
+
+    Parameter<Operation::CREATE_PATH> pCreate;
+    for (auto &[name, subpath] : *this)
+    {
+        if (!subpath.written())
+        {
+            pCreate.path = name;
+            IOHandler()->enqueue(IOTask(&subpath, pCreate));
+        }
+        currentPath.emplace_back(name);
+        subpath.flush_internal(flushParams, mpp, currentPath);
+        currentPath.pop_back();
+    }
+    for (auto &[name, mesh] : data.embeddedMeshesInternal())
+    {
+        if (!mpp.isMeshContainer(currentPath))
+        {
+            std::string extend_meshes_path;
+            // Check if this can be covered by shorthand notation
+            // (e.g. meshesPath == "meshes/")
+            if (!currentPath.empty() &&
+                *currentPath.rbegin() == mpp.m_defaultMeshesPath)
+            {
+                extend_meshes_path = *currentPath.rbegin() + "/";
+            }
+            else
+            {
+                // Otherwise use full path
+                extend_meshes_path = "/" +
+                    (currentPath.empty()
+                         ? ""
+                         : concatWithSep(currentPath, "/") + "/");
+            }
+            mpp.collectNewMeshesPaths.emplace(std::move(extend_meshes_path));
+        }
+        mesh.flush(name, flushParams);
+    }
+    for (auto &[name, particleSpecies] : data.embeddedParticlesInternal())
+    {
+        if (!mpp.isParticleContainer(currentPath))
+        {
+            std::string extend_particles_path;
+            if (!currentPath.empty() &&
+                *currentPath.rbegin() == mpp.m_defaultParticlesPath)
+            {
+                // Check if this can be covered by shorthand notation
+                // (e.g. particlesPath == "particles/")
+                extend_particles_path = *currentPath.rbegin() + "/";
+            }
+            else
+            {
+                // Otherwise use full path
+                extend_particles_path = "/" +
+                    (currentPath.empty()
+                         ? ""
+                         : concatWithSep(currentPath, "/") + "/");
+                ;
+            }
+            mpp.collectNewParticlesPaths.emplace(
+                std::move(extend_particles_path));
+        }
+        particleSpecies.flush(name, flushParams);
+    }
+    for (auto &[name, dataset] : get().embeddedDatasetsInternal())
+    {
+        dataset.flush(name, flushParams, /* set_defaults = */ false);
+    }
+
+    if (flushParams.flushLevel != FlushLevel::SkeletonOnly &&
+        flushParams.flushLevel != FlushLevel::CreateOrOpenFiles)
+    {
+        setDirty(false);
+    }
+}
+
+void CustomHierarchy::flush(
+    std::string const & /* path */, internal::FlushParams const &)
+{
+    throw std::runtime_error(
+        "[CustomHierarchy::flush()] Don't use this method. Flushing should be "
+        "triggered via Iteration class.");
+}
+
+void CustomHierarchy::linkHierarchy(Writable &w)
+{
+    Attributable::linkHierarchy(w);
+}
+} // namespace openPMD
+
+#undef OPENPMD_LEGAL_IDENTIFIER_CHARS
+#undef OPENPMD_SINGLE_GLOBBING_CHAR
+#undef OPENPMD_DOUBLE_GLOBBING_CHAR
+#endif
diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp
index 1d181033eb..1d8a325964 100644
--- a/src/IO/ADIOS/ADIOS2File.cpp
+++ b/src/IO/ADIOS/ADIOS2File.cpp
@@ -1049,25 +1049,16 @@ void ADIOS2File::flush_impl(
         drainedUniquePtrPuts.swap(m_uniquePtrPuts);
     }
 
-    if (readOnly(m_mode))
+    if (readOnly(m_mode) || flush_level::write_datasets(level))
     {
-        level = FlushLevel::UserFlush;
-    }
-
-    switch (level)
-    {
-    case FlushLevel::UserFlush:
         performPutGets(*this, eng);
         m_updateSpans.clear();
         m_buffer.clear();
         m_alreadyEnqueued.clear();
         drainedUniquePtrPuts.clear();
-
-        break;
-
-    case FlushLevel::InternalFlush:
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
+    }
+    else
+    {
         /*
          * Tasks have been given to ADIOS2, but we don't flush them
          * yet. So, move everything to m_alreadyEnqueued to avoid
@@ -1084,7 +1075,6 @@ void ADIOS2File::flush_impl(
                 "wrong time.");
         }
         m_buffer.clear();
-        break;
     }
 }
 
@@ -1366,7 +1356,12 @@ static std::vector<std::string> availableAttributesOrVariablesPrefixed(
     {
         if (auxiliary::starts_with(it->first, var))
         {
-            ret.emplace_back(auxiliary::replace_first(it->first, var, ""));
+            if (it->first.size() > var.size())
+            {
+                ret.emplace_back(auxiliary::replace_first(it->first, var, ""));
+            }
+            // else we have just found the prefix itself.
+            // might happen if prefix == "/"
         }
         else
         {
diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp
index 3f16bcf155..ea7beeb0fc 100644
--- a/src/IO/ADIOS/ADIOS2IOHandler.cpp
+++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp
@@ -582,7 +582,7 @@ overrideFlushTarget(FlushTarget &inplace, FlushTarget new_val)
 std::future<void>
 ADIOS2IOHandlerImpl::flush(internal::ParsedFlushParams &flushParams)
 {
-    auto res = AbstractIOHandlerImpl::flush();
+    auto res = AbstractIOHandlerImpl::flush(flushParams.flushLevel);
 
     detail::ADIOS2File::ADIOS2FlushParams adios2FlushParams{
         flushParams.flushLevel, m_flushTarget};
@@ -803,7 +803,11 @@ void ADIOS2IOHandlerImpl::createPath(
     /* Sanitize path */
     if (!auxiliary::starts_with(parameters.path, '/'))
     {
-        path = filePositionToString(setAndGetFilePosition(writable)) + "/" +
+        auto file_position =
+            filePositionToString(setAndGetFilePosition(writable));
+        path =
+            (auxiliary::ends_with(file_position, '/') ? file_position
+                                                      : file_position + "/") +
             auxiliary::removeSlashes(parameters.path);
     }
     else
diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp
index 5f2bdeb2f5..564eebba01 100644
--- a/src/IO/AbstractIOHandler.cpp
+++ b/src/IO/AbstractIOHandler.cpp
@@ -27,6 +27,29 @@
 
 #include <utility>
 
+namespace openPMD
+{
+std::ostream &operator<<(std::ostream &os, FlushLevel l)
+{
+    switch (l)
+    {
+    case FlushLevel::UserFlush:
+        os << "UserFlush";
+        break;
+    case FlushLevel::InternalFlush:
+        os << "InternalFlush";
+        break;
+    case FlushLevel::SkeletonOnly:
+        os << "SkeletonOnly";
+        break;
+    case FlushLevel::CreateOrOpenFiles:
+        os << "CreateOrOpenFiles";
+        break;
+    }
+    return os;
+}
+} // namespace openPMD
+
 namespace openPMD::auxiliary
 {
 using pair_t = std::pair<OpenpmdStandard, char const *>;
diff --git a/src/IO/AbstractIOHandlerImpl.cpp b/src/IO/AbstractIOHandlerImpl.cpp
index 4f93ff1a5b..b6dfd50a50 100644
--- a/src/IO/AbstractIOHandlerImpl.cpp
+++ b/src/IO/AbstractIOHandlerImpl.cpp
@@ -21,6 +21,8 @@
 
 #include "openPMD/IO/AbstractIOHandlerImpl.hpp"
 
+#include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/IOTask.hpp"
 #include "openPMD/Streaming.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
@@ -87,13 +89,76 @@ void AbstractIOHandlerImpl::writeToStderr([[maybe_unused]] Args &&...args) const
     }
 }
 
-std::future<void> AbstractIOHandlerImpl::flush()
+namespace
+{
+    void verifyFlushType(Operation op, FlushLevel l)
+    {
+        auto do_throw = [&](char const *least_flush_level) {
+            std::stringstream err;
+            err << "Operation " << op << " is not allowed below flush level "
+                << least_flush_level << ", but flush level was " << l << ".";
+            throw error::Internal(err.str());
+        };
+        switch (op)
+        {
+        case Operation::ADVANCE:
+        case Operation::CREATE_FILE:
+        case Operation::CHECK_FILE:
+        case Operation::OPEN_FILE:
+        case Operation::CLOSE_FILE:
+        case Operation::DELETE_FILE:
+        case Operation::DEREGISTER:
+        case Operation::TOUCH:
+        case Operation::LIST_ATTS:
+        case Operation::LIST_PATHS:
+        case Operation::OPEN_PATH:
+        case Operation::SET_WRITTEN:
+        case Operation::CREATE_PATH:
+            break;
+        case Operation::CLOSE_PATH:
+        case Operation::DELETE_PATH:
+        case Operation::CREATE_DATASET:
+        case Operation::EXTEND_DATASET:
+        case Operation::OPEN_DATASET:
+        case Operation::DELETE_DATASET:
+        case Operation::LIST_DATASETS:
+            if (!flush_level::flush_hierarchy(l))
+            {
+                do_throw("SkeletonOnly (hierarchy operations)");
+            }
+            break;
+        case Operation::GET_BUFFER_VIEW:
+        case Operation::DELETE_ATT:
+        case Operation::WRITE_ATT:
+        case Operation::READ_ATT:
+        case Operation::READ_ATT_ALLSTEPS:
+        case Operation::AVAILABLE_CHUNKS:
+            if (!flush_level::write_attributes(l))
+            {
+                do_throw("InternalFlush (metadata operations)");
+            }
+            break;
+        case Operation::WRITE_DATASET:
+        case Operation::READ_DATASET:
+            if (!flush_level::write_datasets(l))
+            {
+                do_throw("UserFlush (flushpoint operations)");
+            }
+            break;
+        }
+    }
+} // namespace
+
+std::future<void> AbstractIOHandlerImpl::flush(FlushLevel l)
 {
     using namespace auxiliary;
 
+    writeToStderr("\nFLUSHING");
+
     while (!(*m_handler).m_work.empty())
     {
         IOTask &i = (*m_handler).m_work.front();
+        // verifyFlushType(i.operation, l);
         try
         {
             switch (i.operation)
@@ -152,6 +217,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     ", extent=",
                     [&parameter]() { return vec_as_string(parameter.extent); });
                 createDataset(i.writable, parameter);
+                i.writable->objectType = ObjectType::Dataset;
                 break;
             }
             case O::EXTEND_DATASET: {
@@ -165,6 +231,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     i.writable,
                     "] EXTEND_DATASET");
                 extendDataset(i.writable, parameter);
+                i.writable->objectType = ObjectType::Dataset;
                 break;
             }
             case O::OPEN_FILE: {
@@ -221,6 +288,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     "] OPEN_DATASET: ",
                     parameter.name);
                 openDataset(i.writable, parameter);
+                i.writable->objectType = ObjectType::Dataset;
                 break;
             }
             case O::DELETE_FILE: {
@@ -280,6 +348,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     ", extent=",
                     [&parameter]() { return vec_as_string(parameter.extent); });
                 writeDataset(i.writable, parameter);
+                i.writable->objectType = ObjectType::Dataset;
                 break;
             }
             case O::WRITE_ATT: {
@@ -311,6 +380,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     ", extent=",
                     [&parameter]() { return vec_as_string(parameter.extent); });
                 readDataset(i.writable, parameter);
+                i.writable->objectType = ObjectType::Dataset;
                 break;
             }
             case O::GET_BUFFER_VIEW: {
@@ -457,11 +527,17 @@ std::future<void> AbstractIOHandlerImpl::flush()
                 auto &parameter = deref_dynamic_cast<Parameter<O::SET_WRITTEN>>(
                     i.parameter.get());
                 writeToStderr(
-                    "[", i.writable->parent, "->", i.writable, "] SET_WRITTEN");
+                    "[",
+                    i.writable->parent,
+                    "->",
+                    i.writable,
+                    "] SET_WRITTEN ",
+                    parameter.target_status ? "true" : "false");
                 setWritten(i.writable, parameter);
                 break;
             }
             }
+            verifyFlushType(i.operation, l);
         }
         catch (...)
         {
@@ -506,6 +582,7 @@ std::future<void> AbstractIOHandlerImpl::flush()
         }
         (*m_handler).m_work.pop();
     }
+    writeToStderr("FLUSHED\n");
     return std::future<void>();
 }
 
diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp
index d859ccc122..b451cd42cf 100644
--- a/src/IO/HDF5/HDF5IOHandler.cpp
+++ b/src/IO/HDF5/HDF5IOHandler.cpp
@@ -3540,7 +3540,7 @@ auto HDF5IOHandlerImpl::requireFile(
 
 std::future<void> HDF5IOHandlerImpl::flush(internal::ParsedFlushParams &params)
 {
-    auto res = AbstractIOHandlerImpl::flush();
+    auto res = AbstractIOHandlerImpl::flush(params.flushLevel);
 
     if (params.backendConfig.json().contains("hdf5"))
     {
diff --git a/src/IO/IOTask.cpp b/src/IO/IOTask.cpp
index 26010ead52..af12ff766c 100644
--- a/src/IO/IOTask.cpp
+++ b/src/IO/IOTask.cpp
@@ -35,6 +35,97 @@ Writable *getWritable(Attributable *a)
     return &a->writable();
 }
 
+std::ostream &operator<<(std::ostream &os, Operation op)
+{
+    switch (op)
+    {
+    case Operation::CREATE_FILE:
+        os << "CREATE_FILE";
+        break;
+    case Operation::CHECK_FILE:
+        os << "CHECK_FILE";
+        break;
+    case Operation::OPEN_FILE:
+        os << "OPEN_FILE";
+        break;
+    case Operation::CLOSE_FILE:
+        os << "CLOSE_FILE";
+        break;
+    case Operation::DELETE_FILE:
+        os << "DELETE_FILE";
+        break;
+    case Operation::CREATE_PATH:
+        os << "CREATE_PATH";
+        break;
+    case Operation::CLOSE_PATH:
+        os << "CLOSE_PATH";
+        break;
+    case Operation::OPEN_PATH:
+        os << "OPEN_PATH";
+        break;
+    case Operation::DELETE_PATH:
+        os << "DELETE_PATH";
+        break;
+    case Operation::LIST_PATHS:
+        os << "LIST_PATHS";
+        break;
+    case Operation::CREATE_DATASET:
+        os << "CREATE_DATASET";
+        break;
+    case Operation::EXTEND_DATASET:
+        os << "EXTEND_DATASET";
+        break;
+    case Operation::OPEN_DATASET:
+        os << "OPEN_DATASET";
+        break;
+    case Operation::DELETE_DATASET:
+        os << "DELETE_DATASET";
+        break;
+    case Operation::WRITE_DATASET:
+        os << "WRITE_DATASET";
+        break;
+    case Operation::READ_DATASET:
+        os << "READ_DATASET";
+        break;
+    case Operation::LIST_DATASETS:
+        os << "LIST_DATASETS";
+        break;
+    case Operation::GET_BUFFER_VIEW:
+        os << "GET_BUFFER_VIEW";
+        break;
+    case Operation::DELETE_ATT:
+        os << "DELETE_ATT";
+        break;
+    case Operation::WRITE_ATT:
+        os << "WRITE_ATT";
+        break;
+    case Operation::READ_ATT:
+        os << "READ_ATT";
+        break;
+    case Operation::READ_ATT_ALLSTEPS:
+        os << "READ_ATT_ALLSTEPS";
+        break;
+    case Operation::LIST_ATTS:
+        os << "LIST_ATTS";
+        break;
+    case Operation::ADVANCE:
+        os << "ADVANCE";
+        break;
+    case Operation::AVAILABLE_CHUNKS:
+        os << "AVAILABLE_CHUNKS";
+        break;
+    case Operation::DEREGISTER:
+        os << "DEREGISTER";
+        break;
+    case Operation::TOUCH:
+        os << "TOUCH";
+        break;
+    case Operation::SET_WRITTEN:
+        os << "SET_WRITTEN";
+        break;
+    }
+    return os;
+}
 template <>
 void AbstractParameter::warnUnusedParameters<json::TracingJSON>(
     json::TracingJSON &config,
diff --git a/src/IO/JSON/JSONIOHandler.cpp b/src/IO/JSON/JSONIOHandler.cpp
index c531aabb00..9af9a06728 100644
--- a/src/IO/JSON/JSONIOHandler.cpp
+++ b/src/IO/JSON/JSONIOHandler.cpp
@@ -53,8 +53,8 @@ JSONIOHandler::JSONIOHandler(
 {}
 #endif
 
-std::future<void> JSONIOHandler::flush(internal::ParsedFlushParams &)
+std::future<void> JSONIOHandler::flush(internal::ParsedFlushParams &params)
 {
-    return m_impl.flush();
+    return m_impl.flush(params);
 }
 } // namespace openPMD
diff --git a/src/IO/JSON/JSONIOHandlerImpl.cpp b/src/IO/JSON/JSONIOHandlerImpl.cpp
index 9308af2e62..0660d1fe41 100644
--- a/src/IO/JSON/JSONIOHandlerImpl.cpp
+++ b/src/IO/JSON/JSONIOHandlerImpl.cpp
@@ -24,6 +24,7 @@
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/AbstractIOHandlerImpl.hpp"
+#include "openPMD/IO/FlushParametersInternal.hpp"
 #include "openPMD/ThrowError.hpp"
 #include "openPMD/auxiliary/Filesystem.hpp"
 #include "openPMD/auxiliary/JSONMatcher.hpp"
@@ -444,9 +445,9 @@ void JSONIOHandlerImpl::init(openPMD::json::TracingJSON config)
 
 JSONIOHandlerImpl::~JSONIOHandlerImpl() = default;
 
-std::future<void> JSONIOHandlerImpl::flush()
+std::future<void> JSONIOHandlerImpl::flush(internal::ParsedFlushParams &params)
 {
-    AbstractIOHandlerImpl::flush();
+    AbstractIOHandlerImpl::flush(params.flushLevel);
     if (access::readOnly(m_handler->m_backendAccess) && !m_dirty.empty())
     {
         throw error::Internal(
@@ -1538,6 +1539,15 @@ void JSONIOHandlerImpl::readAttribute(
     refreshFileFromParent(writable);
     auto name = removeSlashes(parameters.name);
     auto const &jsonContents = obtainJsonContents(writable);
+    if (!hasKey(jsonContents, "attributes"))
+    {
+        throw error::ReadError(
+            error::AffectedObject::Attribute,
+            error::Reason::NotFound,
+            "JSON",
+            "Tried looking up attribute '" + name + "' at location: " +
+                setAndGetFilePosition(writable, false)->id.to_string());
+    }
     auto const &jsonLoc = jsonContents["attributes"];
     setAndGetFilePosition(writable);
     if (!hasKey(jsonLoc, name))
diff --git a/src/Iteration.cpp b/src/Iteration.cpp
index 085495db93..b82bffa0ed 100644
--- a/src/Iteration.cpp
+++ b/src/Iteration.cpp
@@ -30,10 +30,14 @@
 #include "openPMD/auxiliary/DerefDynamicCast.hpp"
 #include "openPMD/auxiliary/Filesystem.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
 #include "openPMD/backend/Writable.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <algorithm>
 #include <exception>
@@ -42,6 +46,7 @@
 #include <optional>
 #include <stdexcept>
 #include <tuple>
+#include <type_traits>
 #include <variant>
 
 namespace openPMD
@@ -49,12 +54,19 @@ namespace openPMD
 using internal::CloseStatus;
 using internal::DeferredParseAccess;
 
+void Meshes::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    visitHierarchyImpl<Meshes>(v, recursive);
+}
+
+void Particles::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    visitHierarchyImpl<Particles>(v, recursive);
+}
+
 Iteration::Iteration() : Attributable(NoInit())
 {
     setData(std::make_shared<Data_t>());
-    setTime(static_cast<double>(0));
-    setDt(static_cast<double>(1));
-    setTimeUnitSI(1);
     meshes.writable().ownKeyWithinParent = "meshes";
     particles.writable().ownKeyWithinParent = "particles";
 }
@@ -122,6 +134,12 @@ Iteration &Iteration::close(bool _flush)
         // yet keeps it re-openable)
         break;
     }
+
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        populateMissingMetadata(true);
+    }
+
     if (_flush)
     {
         if (flag == StepStatus::DuringStep)
@@ -236,6 +254,16 @@ bool Iteration::closedByWriter() const
     }
 }
 
+void Iteration::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    if (recursive)
+    {
+        meshes.visitHierarchy(v, recursive);
+        particles.visitHierarchy(v, recursive);
+    }
+    v(*this);
+}
+
 void Iteration::flushFileBased(
     std::string const &filename,
     IterationIndex_t i,
@@ -252,16 +280,6 @@ void Iteration::flushFileBased(
         fCreate.name = filename;
         IOHandler()->enqueue(IOTask(&s.writable(), fCreate));
 
-        /*
-         * If it was written before, then in the context of another iteration.
-         */
-        auto &attr = s.get().m_rankTable.m_attributable;
-        attr.setWritten(false, Attributable::EnqueueAsynchronously::Both);
-        s.get()
-            .m_rankTable.m_attributable.get()
-            .m_writable.abstractFilePosition.reset();
-        s.flushRankTable();
-
         /* create basePath */
         Parameter<Operation::CREATE_PATH> pCreate;
         pCreate.path = auxiliary::replace_first(s.basePath(), "%T/", "");
@@ -278,15 +296,16 @@ void Iteration::flushFileBased(
         s.openIteration(i, *this);
     }
 
-    switch (flushParams.flushLevel)
+    auto &rankTableAttributable =
+        get().m_perIterationData.m_rankTableAttributable;
+    if (!rankTableAttributable.written())
+    {
+        s.flushRankTable(flushParams.flushLevel, rankTableAttributable);
+    }
+
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -301,15 +320,9 @@ void Iteration::flushGroupBased(
         IOHandler()->enqueue(IOTask(this, pCreate));
     }
 
-    switch (flushParams.flushLevel)
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -324,18 +337,14 @@ void Iteration::flushVariableBased(
         IOHandler()->enqueue(IOTask(this, pOpen));
     }
 
-    switch (flushParams.flushLevel)
+    if (!flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        flush(flushParams);
-        break;
     }
 
-    if (!written())
+    flush(flushParams);
+
+    if (!written() && flush_level::write_datasets(flushParams.flushLevel))
     {
         /* create iteration path */
         Parameter<Operation::OPEN_PATH> pOpen;
@@ -361,13 +370,16 @@ void Iteration::flush(internal::FlushParams const &flushParams)
 {
     Parameter<Operation::TOUCH> touch;
     IOHandler()->enqueue(IOTask(&writable(), touch));
+
+    customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
         for (auto &m : meshes)
             m.second.flush(m.first, flushParams);
         for (auto &species : particles)
             species.second.flush(species.first, flushParams);
-        setDirty(false);
+        determineUnsetDirty(flushParams.flushLevel);
     }
     else
     {
@@ -375,16 +387,28 @@ void Iteration::flush(internal::FlushParams const &flushParams)
          * meshesPath and particlesPath are stored there */
         Series s = retrieveSeries();
 
-        if (!meshes.empty() || s.containsAttribute("meshesPath"))
-        {
-            if (!s.containsAttribute("meshesPath"))
+        auto set_and_get_mp_path =
+            [&](char const *attrName,
+                char const *defaultVal,
+                Series &(Series::*set)(std::string const &)) -> std::string {
+            if (s.containsAttribute(attrName))
+            {
+                return s.getAttribute(attrName).get<std::string>();
+            }
+            else
             {
-                s.setMeshesPath("meshes/");
-                s.flushMeshesPath();
+                (s.*set)(defaultVal);
+                return defaultVal;
             }
+        };
+
+        if (!meshes.empty() || s.containsAttribute("meshesPath"))
+        {
+            auto meshesPath = set_and_get_mp_path(
+                "meshesPath", "meshes/", &Series::setMeshesPath);
             if (meshes.dirtyRecursive())
             {
-                meshes.flush(s.meshesPath(), flushParams);
+                meshes.flush(meshesPath, flushParams);
                 for (auto &m : meshes)
                 {
                     m.second.flush(m.first, flushParams);
@@ -398,14 +422,11 @@ void Iteration::flush(internal::FlushParams const &flushParams)
 
         if (!particles.empty() || s.containsAttribute("particlesPath"))
         {
-            if (!s.containsAttribute("particlesPath"))
-            {
-                s.setParticlesPath("particles/");
-                s.flushParticlesPath();
-            }
+            auto particlesPath = set_and_get_mp_path(
+                "particlesPath", "particles/", &Series::setParticlesPath);
             if (particles.dirtyRecursive())
             {
-                particles.flush(s.particlesPath(), flushParams);
+                particles.flush(particlesPath, flushParams);
                 for (auto &species : particles)
                 {
                     species.second.flush(species.first, flushParams);
@@ -419,11 +440,12 @@ void Iteration::flush(internal::FlushParams const &flushParams)
 
         flushAttributes(flushParams);
     }
+
     if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
     {
-        setDirty(false);
-        meshes.setDirty(false);
-        particles.setDirty(false);
+        determineUnsetDirty(flushParams.flushLevel);
+        meshes.determineUnsetDirty(flushParams.flushLevel);
+        particles.determineUnsetDirty(flushParams.flushLevel);
     }
 }
 
@@ -509,81 +531,6 @@ void Iteration::read_impl(std::string const &groupPath)
     pOpen.path = groupPath;
     IOHandler()->enqueue(IOTask(this, pOpen));
 
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "dt";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    else if (*aRead.dtype == DT::LONG_DOUBLE)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource)
-                  .get<long double>());
-    // conversion cast if a backend reports an integer type
-    else if (
-        auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<double>();
-        val.has_value())
-        setDt(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'dt' (expected double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "time";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        setTime(Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        setTime(
-            Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    else if (*aRead.dtype == DT::LONG_DOUBLE)
-        setTime(Attribute(Attribute::from_any, *aRead.m_resource)
-                    .get<long double>());
-    // conversion cast if a backend reports an integer type
-    else if (
-        auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<double>();
-        val.has_value())
-        setTime(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'time' (expected double, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "timeUnitSI";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<double>();
-        val.has_value())
-        setTimeUnitSI(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'timeUnitSI' (expected double, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
     /* Find the root point [Series] of this file,
      * meshesPath and particlesPath are stored there */
     Series s = retrieveSeries();
@@ -624,7 +571,7 @@ void Iteration::read_impl(std::string const &groupPath)
             std::cerr << "Cannot read meshes in iteration " << groupPath
                       << " and will skip them due to read error:\n"
                       << err.what() << std::endl;
-            meshes.container().clear();
+            meshes.container().for_both([](auto &map) { map.clear(); });
         }
     }
     meshes.setDirty(false);
@@ -640,12 +587,14 @@ void Iteration::read_impl(std::string const &groupPath)
             std::cerr << "Cannot read particles in iteration " << groupPath
                       << " and will skip them due to read error:\n"
                       << err.what() << std::endl;
-            particles.container().clear();
+            particles.container().for_both([](auto &map) { map.clear(); });
         }
     }
     particles.setDirty(false);
 
     readAttributes(ReadMode::FullyReread);
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
+
 #ifdef openPMD_USE_INVASIVE_TESTS
     if (containsAttribute("__openPMD_internal_fail"))
     {
@@ -830,7 +779,7 @@ auto Iteration::beginStep(
     }
     else
     {
-        series.get().m_stepStatus = StepStatus::DuringStep;
+        series.get().m_perIterationData.m_stepStatus = StepStatus::DuringStep;
         status = series.advance(AdvanceMode::BEGINSTEP);
     }
 
@@ -933,10 +882,10 @@ StepStatus Iteration::getStepStatus()
     {
         using IE = IterationEncoding;
     case IE::fileBased:
-        return get().m_stepStatus;
+        return get().m_perIterationData.m_stepStatus;
     case IE::groupBased:
     case IE::variableBased:
-        return s.get().m_stepStatus;
+        return s.get().m_perIterationData.m_stepStatus;
     default:
         throw std::runtime_error("[Iteration] unreachable");
     }
@@ -949,11 +898,11 @@ void Iteration::setStepStatus(StepStatus status)
     {
         using IE = IterationEncoding;
     case IE::fileBased:
-        get().m_stepStatus = status;
+        get().m_perIterationData.m_stepStatus = status;
         break;
     case IE::groupBased:
     case IE::variableBased:
-        s.get().m_stepStatus = status;
+        s.get().m_perIterationData.m_stepStatus = status;
         break;
     default:
         throw std::runtime_error("[Iteration] unreachable");
@@ -965,6 +914,25 @@ void Iteration::linkHierarchy(Writable &w)
     Attributable::linkHierarchy(w);
     meshes.linkHierarchy(this->writable());
     particles.linkHierarchy(this->writable());
+    get().m_perIterationData.m_rankTableAttributable.linkHierarchy(*w.parent);
+
+    auto &container_back = Attributable::get().m_children;
+    auto s = retrieveSeries();
+    auto link_mp = [&](auto &meshes_or_particles,
+                       std::optional<std::string> const &mp_path,
+                       char const *default_) {
+        if (mp_path)
+        {
+            container_back[auxiliary::replace_all_nonrecursively(
+                *mp_path, "/", "")] = *meshes_or_particles.m_attri;
+        }
+        else
+        {
+            container_back[default_] = *meshes_or_particles.m_attri;
+        }
+    };
+    link_mp(meshes, s.meshesPathOptional(), "meshes");
+    link_mp(particles, s.particlesPathOptional(), "particles");
 }
 
 void Iteration::runDeferredParseAccess()
@@ -1013,6 +981,32 @@ void Iteration::runDeferredParseAccess()
     }
 }
 
+void Iteration::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard)
+{
+    using namespace internal;
+    auto float_types = get_float_types();
+    auto int_types = get_int_types();
+
+    defaultAttribute(*this, "time")
+        .template withSetter<Iteration>(0., &Iteration::setTime)
+        .withReader(float_types, require_scalar)
+        .withReader(int_types, require_type<double>())(wor);
+    defaultAttribute(*this, "dt")
+        .template withSetter<Iteration>(1., &Iteration::setDt)
+        .withReader(float_types, require_scalar)
+        .withReader(int_types, require_type<double>())(wor);
+    defaultAttribute(*this, "timeUnitSI")
+        .template withSetter<Iteration>(1.0, &Iteration::setTimeUnitSI)
+        .withReader(float_types, require_type<double>())
+        .withReader(int_types, require_type<double>())(wor);
+}
+
+void Iterations::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    visitHierarchyImpl<Iterations>(v, recursive);
+}
+
 template float Iteration::time<float>() const;
 template double Iteration::time<double>() const;
 template long double Iteration::time<long double>() const;
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index e93b2b5219..6294b99bbc 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -29,24 +29,21 @@
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/backend/Attribute.hpp"
 #include "openPMD/backend/Writable.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <algorithm>
 #include <iostream>
 
 namespace openPMD
 {
-Mesh::Mesh()
+void Mesh::visitHierarchy(HierarchyVisitor &v, bool recursive)
 {
-    setTimeOffset(0.f);
-
-    setGeometry(Geometry::cartesian);
-    setDataOrder(DataOrder::C);
-
-    setAxisLabels({"x"}); // empty strings are not allowed in HDF5
-    setGridSpacing(std::vector<double>{1});
-    setGridGlobalOffset({0});
+    visitHierarchyImpl<Mesh>(v, recursive);
 }
 
+Mesh::Mesh() = default;
+
 Mesh::Geometry Mesh::geometry() const
 {
     std::string ret = geometryString();
@@ -204,28 +201,95 @@ Mesh &Mesh::setGridUnitSI(std::vector<double> const &gusi)
     return setGridUnitSIPerDimension(gusi);
 }
 
-namespace
+auto Mesh::retrieveDimensionality() const -> uint64_t
 {
-    uint64_t retrieveMeshDimensionality(Mesh const &m)
+    if (containsAttribute("axisLabels"))
     {
-        if (m.containsAttribute("axisLabels"))
-        {
-            return m.axisLabels().size();
-        }
+        return axisLabels().size();
+    }
 
-        // maybe we have record components and can ask them
-        if (auto it = m.begin(); it != m.end())
-        {
-            return it->second.getDimensionality();
-        }
-        /*
-         * Since some backends cannot distinguish between vector and
-         * scalar values, the most likely answer here is 1.
-         */
-        return 1;
+    // maybe we have record components and can ask them
+    if (auto it = begin(); it != end())
+    {
+        return it->second.getDimensionality();
     }
-} // namespace
+    /*
+     * Since some backends cannot distinguish between vector and
+     * scalar values, the most likely answer here is 1.
+     */
+    return 1;
+}
 
+void Mesh::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard standard)
+{
+    using namespace internal;
+    auto float_types = get_float_types();
+    auto int_types = get_int_types();
+    auto numerical_types = get_numerical_types();
+    auto string_types = get_string_types();
+    auto dimensionality = retrieveDimensionality();
+
+    defaultAttribute(*this, "geometry")
+        .template withSetter<Mesh>(
+            Mesh::Geometry::cartesian, &Mesh::setGeometry)
+        .withReader(
+            string_types, require_type(*this, &setMeshGeometryFromString))(wor);
+
+    defaultAttribute(*this, "dataOrder")
+        .template withSetter<Mesh>(Mesh::DataOrder::C, &Mesh::setDataOrder)
+        .withReader(
+            string_types, require_type(*this, &setMeshDataOrderFromChar))(wor);
+
+    defaultAttribute(*this, "axisLabels")
+        .template withSetter<Mesh, std::vector<std::string> const &>(
+            [&]() -> std::vector<std::string> {
+                return auxiliary::createDefaultAxisLabels(dimensionality);
+            },
+            &Mesh::setAxisLabels)
+        .withReader(string_types, require_vector)(wor);
+
+    defaultAttribute(*this, "gridSpacing")
+        .template withSetter<Mesh, std::vector<double> const &>(
+            [&]() {
+                return auxiliary::createDefaultVector(dimensionality, 1.0);
+            },
+            &Mesh::setGridSpacing)
+        .withReader(float_types, require_vector)
+        .withReader(int_types, require_type<std::vector<double>>())(wor);
+
+    defaultAttribute(*this, "gridGlobalOffset")
+        .template withSetter<Mesh, std::vector<double> const &>(
+            [&]() {
+                return auxiliary::createDefaultVector(dimensionality, 0.0);
+            },
+            &Mesh::setGridGlobalOffset)
+        .withReader(numerical_types, require_type<std::vector<double>>())(wor);
+
+    defaultAttribute(*this, "timeOffset")
+        .template withSetter<Mesh>(0.f, &Mesh::setTimeOffset)
+        .withReader(float_types, require_scalar)
+        .withReader(int_types, require_type<double>())(wor);
+
+    if (standard >= OpenpmdStandard::v_2_0_0)
+    {
+        defaultAttribute(*this, "gridUnitSI")
+            .template withSetter<Mesh, std::vector<double> const &>(
+                [&]() {
+                    return auxiliary::createDefaultVector(dimensionality, 1.);
+                },
+                &Mesh::setGridUnitSIPerDimension)
+            .withReader(int_types, require_type<std::vector<double>>())(wor);
+    }
+    else
+    {
+        defaultAttribute(*this, "gridUnitSI")
+            .template withSetter<Mesh>(1.0, &Mesh::setGridUnitSI)
+            .withReader(numerical_types, require_type<double>())(wor);
+    }
+
+    BaseRecord<MeshRecordComponent>::scientificDefaults_impl(wor, standard);
+}
 std::vector<double> Mesh::gridUnitSIPerDimension() const
 {
     if (containsAttribute("gridUnitSI"))
@@ -235,7 +299,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
             // If the openPMD version is lower than 2.0, the gridUnitSI is a
             // scalar interpreted for all axes. Copy it d times.
             return std::vector<double>(
-                retrieveMeshDimensionality(*this),
+                retrieveDimensionality(),
                 getAttribute("gridUnitSI").get<double>());
         }
         return getAttribute("gridUnitSI").get<std::vector<double>>();
@@ -244,7 +308,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
     {
         // gridUnitSI is an optional attribute
         // if it is missing, the mesh is interpreted as unscaled
-        return std::vector<double>(retrieveMeshDimensionality(*this), 1.);
+        return std::vector<double>(retrieveDimensionality(), 1.);
     }
 }
 
@@ -269,7 +333,9 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{0};
         unit_representations::auxiliary::fromMapOfUnitDimension(
             tmpUnitDimension.data(), udim);
         setAttribute("unitDimension", tmpUnitDimension);
@@ -285,15 +351,20 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsArray const &udim)
 
 Mesh &Mesh::setGridUnitDimension(unit_representations::AsMaps const &udims)
 {
-    auto rawGridUnitDimension = [this]() {
-        try
+    auto rawGridUnitDimension = [&udims, this]() {
+        if (!this->containsAttribute("gridUnitDimension"))
         {
-            return this->getAttribute("gridUnitDimension")
-                .get<std::vector<double>>();
+            std::vector<double> res(udims.size() * 7);
+            // for (size_t i = 0; i < udims.size(); ++i)
+            // {
+            //     res[7 * i] = 1;
+            // }
+            return res;
         }
-        catch (no_such_attribute_error const &)
+        else
         {
-            return std::vector<double>();
+            return this->getAttribute("gridUnitDimension")
+                .get<std::vector<double>>();
         }
     }();
     rawGridUnitDimension.resize(7 * udims.size());
@@ -341,7 +412,7 @@ unit_representations::AsArrays Mesh::gridUnitDimension() const
         // if it is missing, the mesh is interpreted as spatial
         auto spatialMesh =
             unit_representations::asArray({{UnitDimension::L, 1}});
-        auto dim = retrieveMeshDimensionality(*this);
+        auto dim = retrieveDimensionality();
         unit_representations::AsArrays res(dim, spatialMesh);
         return res;
     }
@@ -380,9 +451,11 @@ void Mesh::flush_impl(
         }
         else
         {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
             for (auto &comp : *this)
                 comp.second.flush(comp.first, flushParams);
         }
+        // TODO why is there no unsetDirty operation here?
     }
     else
     {
@@ -398,6 +471,8 @@ void Mesh::flush_impl(
                 Parameter<Operation::CREATE_PATH> pCreate;
                 pCreate.path = name;
                 IOHandler()->enqueue(IOTask(this, pCreate));
+
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                 {
                     comp.second.parent() = &this->writable();
@@ -413,22 +488,11 @@ void Mesh::flush_impl(
             }
             else
             {
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                     comp.second.flush(comp.first, flushParams);
             }
         }
-        if (!containsAttribute("gridUnitSI"))
-        {
-            if (IOHandler()->m_standard < OpenpmdStandard::v_2_0_0)
-            {
-                setGridUnitSI(1);
-            }
-            else
-            {
-                setGridUnitSIPerDimension(
-                    std::vector<double>(retrieveMeshDimensionality(*this), 1));
-            }
-        }
         flushAttributes(flushParams);
     }
 }
@@ -439,171 +503,6 @@ void Mesh::read()
         IOHandler()->m_verify_homogeneous_extents);
     internal::EraseStaleEntries<Mesh> map{*this};
 
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "geometry";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::STRING)
-    {
-        std::string tmpGeometry =
-            Attribute(Attribute::from_any, *aRead.m_resource)
-                .get<std::string>();
-        if ("cartesian" == tmpGeometry)
-            setGeometry(Geometry::cartesian);
-        else if ("thetaMode" == tmpGeometry)
-            setGeometry(Geometry::thetaMode);
-        else if ("cylindrical" == tmpGeometry)
-            setGeometry(Geometry::cylindrical);
-        else if ("spherical" == tmpGeometry)
-            setGeometry(Geometry::spherical);
-        else
-            setGeometry(tmpGeometry);
-    }
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'geometry' (expected a string, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "dataOrder";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::CHAR)
-        setDataOrder(
-            static_cast<DataOrder>(
-                Attribute(Attribute::from_any, *aRead.m_resource).get<char>()));
-    else if (*aRead.dtype == DT::STRING)
-    {
-        std::string tmpDataOrder =
-            Attribute(Attribute::from_any, *aRead.m_resource)
-                .get<std::string>();
-        if (tmpDataOrder.size() == 1)
-            setDataOrder(static_cast<DataOrder>(tmpDataOrder[0]));
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute value for 'dataOrder': " + tmpDataOrder);
-    }
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'dataOrder' (expected char or "
-            "string, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "axisLabels";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    Attribute a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (auto val = a.getOptional<std::vector<std::string>>(); val.has_value())
-        setAxisLabels(*val);
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'axisLabels' (expected a vector "
-            "of string, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridSpacing";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (*aRead.dtype == DT::VEC_FLOAT || *aRead.dtype == DT::FLOAT)
-        setGridSpacing(a.get<std::vector<float>>());
-    else if (*aRead.dtype == DT::VEC_DOUBLE || *aRead.dtype == DT::DOUBLE)
-        setGridSpacing(a.get<std::vector<double>>());
-    else if (
-        *aRead.dtype == DT::VEC_LONG_DOUBLE || *aRead.dtype == DT::LONG_DOUBLE)
-        setGridSpacing(a.get<std::vector<long double>>());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = a.getOptional<std::vector<double>>(); val.has_value())
-        setGridSpacing(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'gridSpacing' (expected a "
-            "vector of double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridGlobalOffset";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::vector<double>>();
-        val.has_value())
-        setGridGlobalOffset(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'gridGlobalOffset' (expected a "
-            "vector of double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridUnitSI";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (IOHandler()->m_standard >= OpenpmdStandard::v_2_0_0)
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<std::vector<double>>();
-            val.has_value())
-            setGridUnitSIPerDimension(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected vector of double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
-    else
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<double>();
-            val.has_value())
-            setGridUnitSI(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
-
     if (scalar())
     {
         T_RecordComponent::read();
@@ -669,9 +568,8 @@ void Mesh::read()
 
     std::move(homogenizeExtents).homogenize(*this);
 
-    readBase();
-
     readAttributes(ReadMode::FullyReread);
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
 }
 } // namespace openPMD
 
diff --git a/src/ParticlePatches.cpp b/src/ParticlePatches.cpp
index 789559a67f..1803a576ad 100644
--- a/src/ParticlePatches.cpp
+++ b/src/ParticlePatches.cpp
@@ -35,6 +35,11 @@ size_t ParticlePatches::numPatches() const
     return this->at("numParticles").getExtent()[0];
 }
 
+void ParticlePatches::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    visitHierarchyImpl<ParticlePatches>(v, recursive);
+}
+
 void ParticlePatches::read()
 {
     Parameter<Operation::LIST_PATHS> pList;
@@ -56,7 +61,8 @@ void ParticlePatches::read()
             std::cerr << "Cannot read patch record '" << record_name
                       << "' due to read error and will skip it:" << err.what()
                       << std::endl;
-            this->container().erase(record_name);
+            this->container().for_both(
+                [&record_name](auto &map) { map.erase(record_name); });
         }
     }
 
@@ -100,7 +106,7 @@ void ParticlePatches::read()
         pr.setDirty(false);
         try
         {
-            prc.PatchRecordComponent::read(/* require_unit_si = */ false);
+            prc.PatchRecordComponent::read();
         }
         catch (error::ReadError const &err)
         {
@@ -108,7 +114,8 @@ void ParticlePatches::read()
                 << "Cannot read record component '" << component_name
                 << "' in particle patch and will skip it due to read error:\n"
                 << err.what() << std::endl;
-            Container<PatchRecord>::container().erase(component_name);
+            Container<PatchRecord>::container().for_both(
+                [&component_name](auto &map) { map.erase(component_name); });
         }
     }
     setDirty(false);
diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp
index b3e7ea1f7e..aa4d295a56 100644
--- a/src/ParticleSpecies.cpp
+++ b/src/ParticleSpecies.cpp
@@ -20,8 +20,6 @@
  */
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/RecordComponent.hpp"
-#include "openPMD/Series.hpp"
-#include "openPMD/auxiliary/DerefDynamicCast.hpp"
 #include "openPMD/backend/Writable.hpp"
 
 #include <algorithm>
@@ -29,9 +27,20 @@
 
 namespace openPMD
 {
+void ParticleSpecies::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    if (recursive)
+    {
+        particlePatches.visitHierarchy(v, recursive);
+    }
+    visitHierarchyImpl<ParticleSpecies>(v, recursive);
+}
+
 ParticleSpecies::ParticleSpecies()
 {
     particlePatches.writable().ownKeyWithinParent = "particlePatches";
+    container_back(/* verify = */ true)["particlePatches"] =
+        *particlePatches.m_attri;
 }
 
 void ParticleSpecies::read()
@@ -106,9 +115,11 @@ void ParticleSpecies::read()
 
     if (!hasParticlePatches)
     {
-        auto &container = particlePatches.container();
-        container.erase("numParticles");
-        container.erase("numParticlesOffset");
+        auto container = particlePatches.container();
+        container.for_both([](auto &map_) {
+            map_.erase("numParticles");
+            map_.erase("numParticlesOffset");
+        });
         particlePatches.setDirty(false);
     }
 
@@ -171,27 +182,14 @@ void ParticleSpecies::flush(
     }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
         for (auto &record : *this)
             record.second.flush(record.first, flushParams);
         for (auto &patch : particlePatches)
             patch.second.flush(patch.first, flushParams);
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            particlePatches.setDirty(false);
-        }
     }
     else
     {
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            auto it = find("position");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-            it = find("positionOffset");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-        }
-
         Container<Record>::flush(path, flushParams);
 
         for (auto &record : *this)
@@ -203,14 +201,13 @@ void ParticleSpecies::flush(
             for (auto &patch : particlePatches)
                 patch.second.flush(patch.first, flushParams);
         }
-        else
-        {
-            particlePatches.setDirty(false);
-        }
-    }
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
     }
+    determineUnsetDirty(flushParams.flushLevel);
+    particlePatches.determineUnsetDirty(flushParams.flushLevel);
+}
+void ParticleSpecies::scientificDefaults_impl(
+    internal::WriteOrRead, OpenpmdStandard)
+{
+    // no-op
 }
 } // namespace openPMD
diff --git a/src/Record.cpp b/src/Record.cpp
index 8056718edd..0d646c3504 100644
--- a/src/Record.cpp
+++ b/src/Record.cpp
@@ -24,21 +24,26 @@
 #include "openPMD/ThrowError.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <iostream>
 
 namespace openPMD
 {
-Record::Record()
+void Record::visitHierarchy(HierarchyVisitor &v, bool recursive)
 {
-    setTimeOffset(0.f);
+    visitHierarchyImpl<Record>(v, recursive);
 }
+Record::Record() = default;
 
 Record &Record::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);
@@ -66,9 +71,11 @@ void Record::flush_impl(
         }
         else
         {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
             for (auto &comp : *this)
                 comp.second.flush(comp.first, flushParams);
         }
+        // TODO why is there no unsetDirty operation here?
     }
     else
     {
@@ -84,6 +91,8 @@ void Record::flush_impl(
                 Parameter<Operation::CREATE_PATH> pCreate;
                 pCreate.path = name;
                 IOHandler()->enqueue(IOTask(this, pCreate));
+
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                 {
                     comp.second.parent() = getWritable(this);
@@ -93,13 +102,13 @@ void Record::flush_impl(
         }
         else
         {
-
             if (scalar())
             {
                 T_RecordComponent::flush(name, flushParams);
             }
             else
             {
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                     comp.second.flush(comp.first, flushParams);
             }
@@ -121,7 +130,7 @@ auto Record::read() -> internal::HomogenizeExtents
             /* using operator[] will incorrectly update parent */
             try
             {
-                T_RecordComponent::read(/* require_unit_si = */ true);
+                T_RecordComponent::read();
             }
             catch (error::ReadError const &err)
             {
@@ -149,14 +158,15 @@ auto Record::read() -> internal::HomogenizeExtents
             rc.get().m_isConstant = true;
             try
             {
-                rc.read(/* require_unit_si = */ true);
+                rc.read();
             }
             catch (error::ReadError const &err)
             {
                 std::cerr << "Cannot read record component '" << component
                           << "' and will skip it due to read error:\n"
                           << err.what() << std::endl;
-                this->container().erase(component);
+                this->container().for_both(
+                    [&component](auto &map) { map.erase(component); });
                 continue;
             }
             check_extent(rc);
@@ -178,25 +188,51 @@ auto Record::read() -> internal::HomogenizeExtents
             rc.setWritten(true, Attributable::EnqueueAsynchronously::No);
             try
             {
-                rc.read(/* require_unit_si = */ true);
+                rc.read();
             }
             catch (error::ReadError const &err)
             {
                 std::cerr << "Cannot read record component '" << component
                           << "' and will skip it due to read error:\n"
                           << err.what() << std::endl;
-                this->container().erase(component);
+                this->container().for_both(
+                    [&component](auto &map) { map.erase(component); });
                 continue;
             }
             check_extent(rc);
         }
     }
 
-    readBase();
-
     readAttributes(ReadMode::FullyReread);
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
+
     return res;
 }
 
+void Record::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard standard)
+{
+    using namespace internal;
+    auto float_types = get_float_types();
+    auto int_types = get_int_types();
+
+    defaultAttribute(*this, "timeOffset")
+        .template withSetter<Record>(0.f, &Record::setTimeOffset)
+        .withReader(float_types, require_scalar)
+        .withReader(int_types, require_type<double>())(wor);
+
+    auto const &keyInParent = writable().ownKeyWithinParent;
+    if (keyInParent == "position" || keyInParent == "positionOffset")
+    {
+        defaultAttribute(*this, "unitDimension")
+            .template withSetter<Record, unit_representations::AsMap const &>(
+                []() {
+                    return unit_representations::AsMap{{UnitDimension::L, 1.0}};
+                },
+                &Record::setUnitDimension)(wor);
+    }
+
+    BaseRecord<RecordComponent>::scientificDefaults_impl(wor, standard);
+}
 template class BaseRecord<RecordComponent>;
 } // namespace openPMD
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
index fbf2ad0d88..092b8ef3fb 100644
--- a/src/RecordComponent.cpp
+++ b/src/RecordComponent.cpp
@@ -22,6 +22,7 @@
 #include "openPMD/Dataset.hpp"
 #include "openPMD/DatatypeHelpers.hpp"
 #include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/Format.hpp"
 #include "openPMD/Series.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
@@ -30,6 +31,8 @@
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 // comment so clang-format does not move this
 #include "openPMD/DatatypeMacros.hpp"
@@ -213,9 +216,37 @@ RecordComponent &RecordComponent::setUnitSI(double usi)
     return *this;
 }
 
+namespace
+{
+    template <typename F>
+    struct defer_type
+    {
+        F functor;
+        ~defer_type()
+        {
+            std::move(functor)();
+        }
+    };
+
+    template <typename F>
+    auto defer(F &&functor) -> defer_type<std::remove_reference_t<F>>
+    {
+        return defer_type<std::remove_reference_t<F>>{std::forward<F>(functor)};
+    }
+} // namespace
+
 RecordComponent &RecordComponent::resetDataset(Dataset d)
 {
     auto &rc = get();
+    auto cleanup = defer([&rc, this]() {
+        if (rc.m_dataset.has_value() &&
+            rc.m_dataset->dtype != Datatype::UNDEFINED &&
+            IOHandler()->m_seriesStatus != internal::SeriesStatus::Parsing)
+        {
+            seriesFlush_impl</* flush_entire_series = */ false>(
+                {FlushLevel::SkeletonOnly}, /* flush_io_handler = */ true);
+        }
+    });
     if (written())
     {
         if (!rc.m_dataset.has_value())
@@ -249,11 +280,13 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)
         }
         else if (d.dtype != Datatype::UNDEFINED)
         {
+            setDirty(true);
             return makeEmpty(std::move(d));
         }
         else
         {
             rc.m_dataset = std::move(d);
+            setDirty(true);
             return *this;
         }
     }
@@ -381,6 +414,11 @@ bool RecordComponent::empty() const
     return get().m_isEmpty;
 }
 
+void RecordComponent::visitHierarchy(HierarchyVisitor &v, bool)
+{
+    v(*this);
+}
+
 void RecordComponent::flush(
     std::string const &name, internal::FlushParams const &flushParams)
 {
@@ -395,6 +433,9 @@ void RecordComponent::flush(
     }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
+        // TODO maybe guard against custom hierarchies on datasets?
+        // they can be created upon constant components however..
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
         while (!rc.m_chunks.empty())
         {
             IOHandler()->enqueue(rc.m_chunks.front());
@@ -425,10 +466,6 @@ void RecordComponent::flush(
                     "RecordComponent::resetDataset()).");
             }
         }
-        if (!containsAttribute("unitSI"))
-        {
-            setUnitSI(1);
-        }
         auto constant_component_write_shape = [&]() {
             auto extent = getExtent();
             return !Dataset::undefinedExtent(extent) &&
@@ -518,17 +555,19 @@ void RecordComponent::flush(
             rc.m_chunks.pop();
         }
 
+        // TODO maybe guard against custom hierarchies on datasets?
+        // they can be created upon constant components however..
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+
         flushAttributes(flushParams);
     }
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
-void RecordComponent::read(bool require_unit_si)
+void RecordComponent::read()
 {
-    readBase(require_unit_si);
+    readBase();
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
 }
 
 namespace
@@ -553,7 +592,7 @@ namespace
     };
 } // namespace
 
-void RecordComponent::readBase(bool require_unit_si)
+void RecordComponent::readBase()
 {
     using DT = Datatype;
     auto &rc = get();
@@ -605,32 +644,6 @@ void RecordComponent::readBase(bool require_unit_si)
     {
         read_constant();
     }
-
-    if (require_unit_si)
-    {
-        if (!containsAttribute("unitSI"))
-        {
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::NotFound,
-                {},
-                "Attribute unitSI required for record components, not found in "
-                "'" +
-                    myPath().openPMDPath() + "'.");
-        }
-        if (auto attr = getAttribute("unitSI");
-            !attr.getOptional<double>().has_value())
-        {
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'unitSI' (expected double, "
-                "found " +
-                    datatypeToString(attr.dtype) + ") in '" +
-                    myPath().openPMDPath() + "'.");
-        }
-    }
 }
 
 void RecordComponent::storeChunk(
@@ -720,6 +733,16 @@ void RecordComponent::verifyChunk(
     }
 }
 
+void RecordComponent::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard)
+{
+    using namespace internal;
+    auto numerical_types = get_numerical_types();
+
+    defaultAttribute(*this, "unitSI")
+        .template withSetter<RecordComponent>(1.0, &RecordComponent::setUnitSI)
+        .withReader(numerical_types, require_type<double>())(wor);
+}
 namespace
 {
     struct LoadChunkVariant
diff --git a/src/Series.cpp b/src/Series.cpp
index 038bffc7cc..85f86a6c11 100644
--- a/src/Series.cpp
+++ b/src/Series.cpp
@@ -36,6 +36,7 @@
 #include "openPMD/auxiliary/Environment.hpp"
 #include "openPMD/auxiliary/Filesystem.hpp"
 #include "openPMD/auxiliary/JSON_internal.hpp"
+#include "openPMD/auxiliary/MonadicOperations.hpp"
 #include "openPMD/auxiliary/Mpi.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
@@ -272,6 +273,13 @@ std::string Series::meshesPath() const
     return getAttribute("meshesPath").get<std::string>();
 }
 
+std::optional<std::string> Series::meshesPathOptional() const
+{
+    return auxiliary::optional_and_then(
+        getAttributeOptional("meshesPath"),
+        [](Attribute const &attr) { return attr.getOptional<std::string>(); });
+}
+
 Series &Series::setMeshesPath(std::string const &mp)
 {
     auto &series = get();
@@ -285,12 +293,7 @@ Series &Series::setMeshesPath(std::string const &mp)
             "A files meshesPath can not (yet) be changed after it has been "
             "written.");
 
-    if (auxiliary::ends_with(mp, '/'))
-        setAttribute("meshesPath", mp);
-    else
-        setAttribute("meshesPath", mp + "/");
-    setDirty(true);
-    return *this;
+    return setMeshesPath_internal(mp);
 }
 
 std::vector<std::string> Series::availableDatasets()
@@ -339,10 +342,11 @@ chunk_assignment::RankMeta Series::rankTable([[maybe_unused]] bool collective)
     }
     if (iterationEncoding() == IterationEncoding::fileBased)
     {
-        std::cerr << "[Series] Use rank table in file-based iteration encoding "
-                     "at your own risk. Make sure to have an iteration open "
-                     "before calling this."
-                  << std::endl;
+        std::cerr
+            << "[Series] Use rank table in file-based iteration encoding "
+               "at your own risk. Make sure to have the first iteration open "
+               "before calling this."
+            << std::endl;
         if (iterations.empty())
         {
             return {};
@@ -355,6 +359,18 @@ chunk_assignment::RankMeta Series::rankTable([[maybe_unused]] bool collective)
         IOHandler()->enqueue(IOTask(this, openFile));
 #endif
     }
+    Attributable &attributable =
+        iterationEncoding() == IterationEncoding::fileBased
+        /*
+         * Only second class support for file encoding. We indiscriminately use
+         * the first Iteration for this operation. It is on the user to ensure
+         * that this Iteration is actually open. The warning printed above
+         * informs about this.
+         */
+        ? iterations.begin()
+              ->second.get()
+              .m_perIterationData.m_rankTableAttributable
+        : series.m_perIterationData.m_rankTableAttributable;
     auto datasets = availableDatasets();
     if (std::find(datasets.begin(), datasets.end(), "rankTable") ==
         datasets.end())
@@ -364,7 +380,7 @@ chunk_assignment::RankMeta Series::rankTable([[maybe_unused]] bool collective)
     }
     Parameter<Operation::OPEN_DATASET> openDataset;
     openDataset.name = "rankTable";
-    IOHandler()->enqueue(IOTask(&rankTable.m_attributable, openDataset));
+    IOHandler()->enqueue(IOTask(&attributable, openDataset));
 
     IOHandler()->flush(internal::defaultFlushParams);
     if (openDataset.extent->size() != 2)
@@ -394,7 +410,7 @@ chunk_assignment::RankMeta Series::rankTable([[maybe_unused]] bool collective)
         new char[writerRanks * lineWidth],
         [](char const *ptr) { delete[] ptr; }};
 
-    auto doReadDataset = [&openDataset, this, &get, &rankTable]() {
+    auto doReadDataset = [&openDataset, this, &get, &attributable]() {
         Parameter<Operation::READ_DATASET> readDataset;
         // read the whole thing
         readDataset.offset.resize(2);
@@ -404,8 +420,8 @@ chunk_assignment::RankMeta Series::rankTable([[maybe_unused]] bool collective)
         readDataset.dtype = Datatype::CHAR;
         readDataset.data = get;
 
-        IOHandler()->enqueue(IOTask(&rankTable.m_attributable, readDataset));
-        IOHandler()->flush(internal::defaultFlushParams);
+        IOHandler()->enqueue(IOTask(&attributable, readDataset));
+        IOHandler()->flush(internal::publicFlush);
     };
 
 #if openPMD_HAVE_MPI
@@ -464,8 +480,12 @@ Series &Series::setRankTable(const std::string &myRankInfo)
     return *this;
 }
 
-void Series::flushRankTable()
+void Series::flushRankTable(FlushLevel l, Attributable &attributable)
 {
+    if (!flush_level::global_flushpoint(l))
+    {
+        return;
+    }
     auto &series = get();
     auto &rankTable = series.m_rankTable;
     auto maybeMyRankInfo = std::visit(
@@ -508,8 +528,8 @@ void Series::flushRankTable()
     int rank{0}, size{1};
     unsigned long long maxSize = mySize;
 
-    auto createRankTable = [&size, &maxSize, &rankTable, this]() {
-        if (rankTable.m_attributable.written())
+    auto createRankTable = [&size, &maxSize, this, &attributable]() {
+        if (attributable.written())
         {
             return;
         }
@@ -518,19 +538,17 @@ void Series::flushRankTable()
         param.name = "rankTable";
         param.dtype = Datatype::CHAR;
         param.extent = {uint64_t(size), uint64_t(maxSize)};
-        IOHandler()->enqueue(
-            IOTask(&rankTable.m_attributable, std::move(param)));
+        IOHandler()->enqueue(IOTask(&attributable, std::move(param)));
     };
 
-    auto writeDataset = [&rank, &maxSize, this, &rankTable](
+    auto writeDataset = [&rank, &maxSize, this, &attributable](
                             std::shared_ptr<char> put, size_t num_lines = 1) {
         Parameter<Operation::WRITE_DATASET> chunk;
         chunk.dtype = Datatype::CHAR;
         chunk.offset = {uint64_t(rank), 0};
         chunk.extent = {num_lines, maxSize};
         chunk.data = std::move(put);
-        IOHandler()->enqueue(
-            IOTask(&rankTable.m_attributable, std::move(chunk)));
+        IOHandler()->enqueue(IOTask(&attributable, std::move(chunk)));
     };
 
 #if openPMD_HAVE_MPI
@@ -574,8 +592,7 @@ void Series::flushRankTable()
 
         // Must ensure that the Writable is consistently set to written on all
         // ranks
-        series.m_rankTable.m_attributable.setWritten(
-            true, EnqueueAsynchronously::OnlyAsync);
+        attributable.setWritten(true, EnqueueAsynchronously::OnlyAsync);
         return;
     }
 #endif
@@ -596,6 +613,13 @@ std::string Series::particlesPath() const
     return getAttribute("particlesPath").get<std::string>();
 }
 
+std::optional<std::string> Series::particlesPathOptional() const
+{
+    return auxiliary::optional_and_then(
+        getAttributeOptional("particlesPath"),
+        [](Attribute const &attr) { return attr.getOptional<std::string>(); });
+}
+
 Series &Series::setParticlesPath(std::string const &pp)
 {
     auto &series = get();
@@ -609,12 +633,7 @@ Series &Series::setParticlesPath(std::string const &pp)
             "A files particlesPath can not (yet) be changed after it has been "
             "written.");
 
-    if (auxiliary::ends_with(pp, '/'))
-        setAttribute("particlesPath", pp);
-    else
-        setAttribute("particlesPath", pp + "/");
-    setDirty(true);
-    return *this;
+    return setParticlesPath_internal(pp);
 }
 
 std::string Series::author() const
@@ -981,7 +1000,8 @@ void Series::init(
                 std::make_unique<DummyIOHandler>(parsed_directory, at));
         auto &series = get();
         series.iterations.linkHierarchy(writable());
-        series.m_rankTable.m_attributable.linkHierarchy(writable());
+        series.m_perIterationData.m_rankTableAttributable.linkHierarchy(
+            writable());
         series.m_deferred_initialization =
             [called_this_already = false,
              filepath,
@@ -1207,7 +1227,10 @@ void Series::initSeries(
 
     series.iterations.linkHierarchy(writable);
     series.iterations.writable().ownKeyWithinParent = "data";
-    series.m_rankTable.m_attributable.linkHierarchy(writable);
+    series->m_writable.ownKeyWithinParent = "ROOT";
+    auto &container_back = series->m_children;
+    container_back["data"] = *series.iterations.m_attri;
+    series.m_perIterationData.m_rankTableAttributable.linkHierarchy(writable);
 
     series.m_name = input->name;
 
@@ -1469,6 +1492,12 @@ void Series::flushFileBased(
             case IO::HasBeenOpened:
                 // continue below
                 it->second.flush(flushParams);
+
+                if (it == begin)
+                {
+                    customHierarchyFlush(
+                        flushParams, /* unset_dirty = */ false);
+                }
                 break;
             }
 
@@ -1494,6 +1523,12 @@ void Series::flushFileBased(
     case Access::APPEND_RANDOM_ACCESS:
     case Access::APPEND_LINEAR: {
         bool allDirty = dirty();
+        // In flush level SkeletonOnly, we might need to set some attributes
+        // (especially: particlesPath, meshesPath), but cannot flush them yet
+        // (as writing attributes is only permissible at higher flush levels).
+        // This flag records if the Series became dirty during this flush. If
+        // yes, we set the Series back to dirty at the end of flushing.
+        bool hasBecomeDirty = false;
         for (auto it = begin; it != end; ++it)
         {
             // Phase 1
@@ -1522,6 +1557,12 @@ void Series::flushFileBased(
 
                 it->second.flushFileBased(filename, it->first, flushParams);
 
+                if (it == begin)
+                {
+                    customHierarchyFlush(
+                        flushParams, /* unset_dirty = */ false);
+                }
+
                 series.iterations.flush(
                     auxiliary::replace_first(basePath(), "%T/", ""),
                     flushParams);
@@ -1543,11 +1584,30 @@ void Series::flushFileBased(
             }
             /* reset the dirty bit for every iteration (i.e. file)
              * otherwise only the first iteration will have updates attributes
+             * TODO: Ideally, we would skip this in SkeletonOnly flush mode, but
+             * for some reason, this leads to hanging parallel tests..?
              */
+            if (flushParams.flushLevel == FlushLevel::SkeletonOnly)
+            {
+                if (allDirty && !dirty())
+                {
+                    throw error::Internal(
+                        "Flush mode SkeletonOnly must not unset dirty flags.");
+                }
+                hasBecomeDirty |=
+                    flushParams.flushLevel == FlushLevel::SkeletonOnly &&
+                    !allDirty && dirty();
+            }
             setDirty(allDirty);
         }
-        setDirty(false);
-
+        if (!hasBecomeDirty)
+        {
+            determineUnsetDirty(flushParams.flushLevel);
+        }
+        else
+        {
+            setDirty(true);
+        }
         // Phase 3
         if (flushIOHandler)
         {
@@ -1587,7 +1647,14 @@ void Series::flushGorVBased(
                         series.m_snapshotToStep.at(it->first)};
                     IOHandler()->enqueue(IOTask(this, std::move(param)));
                 }
+
                 it->second.flush(flushParams);
+
+                if (it == begin)
+                {
+                    customHierarchyFlush(
+                        flushParams, /* unset_dirty = */ false);
+                }
                 break;
             }
 
@@ -1600,6 +1667,11 @@ void Series::flushGorVBased(
             }
         }
 
+        if (begin == end)
+        {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+        }
+
         // Phase 3
         Parameter<Operation::TOUCH> touch;
         IOHandler()->enqueue(IOTask(&writable(), touch));
@@ -1632,8 +1704,13 @@ void Series::flushGorVBased(
             Parameter<Operation::CREATE_FILE> fCreate;
             fCreate.name = series.m_name;
             IOHandler()->enqueue(IOTask(this, fCreate));
+        }
 
-            flushRankTable();
+        if (!series.m_perIterationData.m_rankTableAttributable.written())
+        {
+            flushRankTable(
+                flushParams.flushLevel,
+                series.m_perIterationData.m_rankTableAttributable);
         }
 
         series.iterations.flush(
@@ -1664,6 +1741,13 @@ void Series::flushGorVBased(
                     throw std::runtime_error(
                         "[Series] Internal control flow error");
                 }
+
+                if (it == begin)
+                {
+                    customHierarchyFlush(
+                        flushParams, /* unset_dirty = */ false);
+                }
+
                 break;
             case IO::RemainsClosed:
                 break;
@@ -1678,6 +1762,11 @@ void Series::flushGorVBased(
             }
         }
 
+        if (begin == end)
+        {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+        }
+
         flushAttributes(flushParams);
         Parameter<Operation::TOUCH> touch;
         IOHandler()->enqueue(IOTask(&writable(), touch));
@@ -1688,26 +1777,6 @@ void Series::flushGorVBased(
     }
 }
 
-void Series::flushMeshesPath()
-{
-    Parameter<Operation::WRITE_ATT> aWrite;
-    aWrite.name = "meshesPath";
-    Attribute a = getAttribute("meshesPath");
-    aWrite.m_resource = a.getAny();
-    aWrite.dtype = a.dtype;
-    IOHandler()->enqueue(IOTask(this, aWrite));
-}
-
-void Series::flushParticlesPath()
-{
-    Parameter<Operation::WRITE_ATT> aWrite;
-    aWrite.name = "particlesPath";
-    Attribute a = getAttribute("particlesPath");
-    aWrite.m_resource = a.getAny();
-    aWrite.dtype = a.dtype;
-    IOHandler()->enqueue(IOTask(this, aWrite));
-}
-
 void Series::readFileBased(
     std::optional<IterationIndex_t> read_only_this_single_iteration)
 {
@@ -1918,7 +1987,10 @@ void Series::readFileBased(
 
     for (auto index : unparseableIterations)
     {
-        series.iterations.container().erase(index);
+        series.iterations.container().for_both_to_string(
+            [index](auto &map, auto &&to_string) {
+                map.erase(to_string(index));
+            });
     }
 
     if (padding > 0)
@@ -2254,7 +2326,10 @@ creating new iterations.
                     std::cerr << "Cannot read iteration '" << index
                               << "' and will skip it due to read error:\n"
                               << err.what() << std::endl;
-                    series.iterations.container().erase(index);
+                    series.iterations.container().for_both_to_string(
+                        [index](auto &map, auto &&to_string) {
+                            map.erase(to_string(index));
+                        });
                     return {err};
                 }
                 i.get().m_closed = internal::CloseStatus::Open;
@@ -2285,7 +2360,17 @@ creating new iterations.
         readableIterations.reserve(pList.paths->size());
         for (auto const &it : *pList.paths)
         {
-            IterationIndex_t index = std::stoull(it);
+            IterationIndex_t index;
+            try
+            {
+                index = std::stoull(it);
+            }
+            catch (std::exception const &e)
+            {
+                std::cerr << "[Warning] Could not parse '" << it
+                          << "' as an Iteration index. Will skip." << std::endl;
+                continue;
+            }
             if (read_only_this_single_iteration.has_value() &&
                 index != *read_only_this_single_iteration)
             {
@@ -2416,7 +2501,6 @@ creating new iterations.
 
 void Series::readBase()
 {
-    auto &series = get();
     Parameter<Operation::READ_ATT> aRead;
 
     aRead.name = "openPMD";
@@ -2502,16 +2586,9 @@ void Series::readBase()
                            .getOptional<std::string>();
             val.has_value())
         {
-            /* allow setting the meshes path after completed IO */
-            for (auto &it : series.iterations)
-                it.second.meshes.setWritten(
-                    false, Attributable::EnqueueAsynchronously::No);
-
-            setMeshesPath(val.value());
-
-            for (auto &it : series.iterations)
-                it.second.meshes.setWritten(
-                    true, Attributable::EnqueueAsynchronously::No);
+            /* use internal api to allow setting the meshes path after completed
+             * IO */
+            setMeshesPath_internal(val.value());
         }
         else
             throw error::ReadError(
@@ -2544,16 +2621,9 @@ void Series::readBase()
                            .getOptional<std::string>();
             val.has_value())
         {
-            /* allow setting the meshes path after completed IO */
-            for (auto &it : series.iterations)
-                it.second.particles.setWritten(
-                    false, Attributable::EnqueueAsynchronously::No);
-
-            setParticlesPath(val.value());
-
-            for (auto &it : series.iterations)
-                it.second.particles.setWritten(
-                    true, Attributable::EnqueueAsynchronously::No);
+            /* use internal api to allow setting the meshes path after completed
+             * IO */
+            setParticlesPath_internal(val.value());
         }
         else
             throw error::ReadError(
@@ -2700,7 +2770,7 @@ AdvanceStatus Series::advance(
 
     if (mode == AdvanceMode::ENDSTEP)
     {
-        flushStep(/* doFlush = */ false);
+        flushStep(/* doFlush = */ false, FlushLevel::UserFlush);
     }
 
     Parameter<Operation::ADVANCE> param;
@@ -2806,7 +2876,7 @@ AdvanceStatus Series::advance(AdvanceMode mode)
 
     if (mode == AdvanceMode::ENDSTEP)
     {
-        flushStep(/* doFlush = */ false);
+        flushStep(/* doFlush = */ false, FlushLevel::UserFlush);
     }
 
     Parameter<Operation::ADVANCE> param;
@@ -2829,8 +2899,12 @@ AdvanceStatus Series::advance(AdvanceMode mode)
     return *param.status;
 }
 
-void Series::flushStep(bool doFlush)
+void Series::flushStep(bool doFlush, FlushLevel l)
 {
+    if (!flush_level::write_datasets(l))
+    {
+        return;
+    }
     auto &series = get();
     if (!series.m_currentlyActiveIterations.empty() &&
         access::write(IOHandler()->m_frontendAccess))
@@ -2913,6 +2987,25 @@ Series &Series::setIterationEncoding_internal(
     return *this;
 }
 
+Series &Series::setParticlesPath_internal(std::string const &pp)
+{
+    if (auxiliary::ends_with(pp, '/'))
+        setAttribute("particlesPath", pp);
+    else
+        setAttribute("particlesPath", pp + "/");
+    setDirty(true);
+    return *this;
+}
+
+Series &Series::setMeshesPath_internal(std::string const &mp)
+{
+    if (auxiliary::ends_with(mp, '/'))
+        setAttribute("meshesPath", mp);
+    else
+        setAttribute("meshesPath", mp + "/");
+    setDirty(true);
+    return *this;
+}
 auto Series::openIterationIfDirty(IterationIndex_t index, Iteration &iteration)
     -> IterationOpened
 {
@@ -3317,6 +3410,14 @@ namespace internal
             !(access::readOnly(IOHandler->m_frontendAccess) &&
               !(*this)->m_writable.written))
         {
+            for (auto &[_, iteration] : iterations)
+            {
+                (void)_;
+                if (!iteration.closed())
+                {
+                    iteration.close(/* flush = */ false);
+                }
+            }
             impl.flush();
             /*
              * In file-based iteration encoding, this must be triggered by
@@ -3326,12 +3427,12 @@ namespace internal
              */
             if (impl.iterationEncoding() != IterationEncoding::fileBased)
             {
-                impl.flushStep(/* doFlush = */ true);
+                impl.flushStep(/* doFlush = */ true, FlushLevel::UserFlush);
             }
         }
         // Not strictly necessary, but clear the map of iterations
         // This releases the openPMD hierarchy
-        iterations.container().clear();
+        iterations.container().for_both([](auto &map) { map.clear(); });
         // Release the IO Handler
         if (IOHandler)
         {
@@ -3556,6 +3657,15 @@ void Series::close()
     m_attri.reset();
 }
 
+void Series::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    if (recursive)
+    {
+        get().iterations.visitHierarchy(v, recursive);
+    }
+    v(*this);
+}
+
 auto Series::currentSnapshot() -> std::optional<std::vector<IterationIndex_t>>
 {
     using vec_t = std::vector<IterationIndex_t>;
diff --git a/src/auxiliary/Mpi.cpp b/src/auxiliary/Mpi.cpp
index ef899e4207..5e8379ff41 100644
--- a/src/auxiliary/Mpi.cpp
+++ b/src/auxiliary/Mpi.cpp
@@ -49,7 +49,7 @@ StringMatrix collectStringsAsMatrixTo(
         1,
         MPI_INT,
         destRank,
-        MPI_COMM_WORLD);
+        communicator);
     int maxLength = std::accumulate(
         recvcounts.begin(), recvcounts.end(), 0, [](int a, int b) {
             return std::max(a, b);
@@ -78,7 +78,7 @@ StringMatrix collectStringsAsMatrixTo(
         displs.data(),
         MPI_CHAR,
         destRank,
-        MPI_COMM_WORLD);
+        communicator);
 
     return res;
 }
@@ -95,7 +95,7 @@ std::vector<std::string> distributeStringsToAllRanks(
     int *displs = new int[size];
 
     MPI_Allgather(
-        &sendLength, 1, MPI_INT, sizesBuffer, 1, MPI_INT, MPI_COMM_WORLD);
+        &sendLength, 1, MPI_INT, sizesBuffer, 1, MPI_INT, communicator);
 
     char *namesBuffer;
     {
@@ -116,7 +116,7 @@ std::vector<std::string> distributeStringsToAllRanks(
         sizesBuffer,
         displs,
         MPI_CHAR,
-        MPI_COMM_WORLD);
+        communicator);
 
     std::vector<std::string> hostnames(size);
     for (int i = 0; i < size; ++i)
diff --git a/src/backend/Attributable.cpp b/src/backend/Attributable.cpp
index dd9019b255..1bf3e3f71e 100644
--- a/src/backend/Attributable.cpp
+++ b/src/backend/Attributable.cpp
@@ -19,7 +19,10 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/CustomHierarchy.hpp"
+#include "openPMD/Error.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/Access.hpp"
 #include "openPMD/Iteration.hpp"
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/RecordComponent.hpp"
@@ -27,6 +30,8 @@
 #include "openPMD/auxiliary/DerefDynamicCast.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/HierarchyVisitorImpl.hpp"
+#include "openPMD/backend/Writable.hpp"
 
 #include <algorithm>
 #include <complex>
@@ -51,12 +56,10 @@ namespace internal
         : SharedData_t({raw_ptr, [](auto const *) {}})
     {}
 
-    void AttributableData::cloneFrom(AttributableData const &other)
+    void AttributableData::cloneFrom(parent_t const &other)
     {
-        using parent_t = std::shared_ptr<SharedAttributableData>;
         static_cast<parent_t &>(*this) = static_cast<parent_t const &>(other);
     }
-
 } // namespace internal
 
 Attributable::Attributable()
@@ -72,14 +75,56 @@ Attributable::Attributable()
 Attributable::Attributable(NoInit) noexcept
 {}
 
+bool Attributable::setAttribute(std::string const &key, Attribute attribute)
+{
+    auto &attri = get();
+    if (IOHandler() &&
+        IOHandler()->m_seriesStatus == internal::SeriesStatus::Default &&
+        Access::READ_ONLY == IOHandler()->m_frontendAccess)
+    {
+        auxiliary::OutOfRangeMsg const out_of_range_msg(
+            "Attribute", "can not be set (read-only).");
+        error::throwNoSuchAttribute(out_of_range_msg(key));
+    }
+
+    setDirty(true);
+    auto it = attri.m_attributes.lower_bound(key);
+    if (it != attri.m_attributes.end() &&
+        !attri.m_attributes.key_comp()(key, it->first))
+    {
+        // key already exists in map, just replace the value
+        it->second = std::move(attribute);
+        return true;
+    }
+    else
+    {
+        // emplace a new map element for an unknown key
+        attri.m_attributes.emplace_hint(
+            it, std::make_pair(key, std::move(attribute)));
+        return false;
+    }
+}
+
 Attribute Attributable::getAttribute(std::string const &key) const
+{
+    auto attribute = getAttributeOptional(key);
+    if (attribute.has_value())
+    {
+        return *attribute;
+    }
+
+    throw no_such_attribute_error(key);
+}
+
+std::optional<Attribute>
+Attributable::getAttributeOptional(std::string const &key) const
 {
     auto &attri = get();
     auto it = attri.m_attributes.find(key);
     if (it != attri.m_attributes.cend())
         return it->second;
 
-    throw no_such_attribute_error(key);
+    return std::nullopt;
 }
 
 bool Attributable::deleteAttribute(std::string const &key)
@@ -147,6 +192,58 @@ void Attributable::iterationFlush(std::string backendConfig)
         std::move(backendConfig));
 }
 
+void Attributable::customHierarchyFlush(
+    internal::FlushParams const &flushParams, bool unset_dirty)
+{
+    // customHierarchies().printRecursively();
+    if (!dirtyRecursive())
+    {
+        return;
+    }
+
+    /*
+     * Convention for CustomHierarchy::flush and CustomHierarchy::read:
+     * Path is created/opened already at entry point of method, method needs
+     * to create/open path for contained subpaths.
+     */
+
+    // No need to do anything in access::readOnly since meshes and particles
+    // are initialized as aliases for subgroups at parsing time
+    auto &data = get();
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        flushAttributes(flushParams);
+    }
+
+    Parameter<Operation::CREATE_PATH> pCreate;
+    for (auto &[name, subpath] : data.m_children_managed_as_custom_hierarchy)
+    {
+        auto backpointer = subpath.writable().attributable;
+        auto casted_backpointer =
+            dynamic_cast<CustomHierarchy::Data_t *>(backpointer);
+        if (!casted_backpointer)
+        {
+            throw error::Internal(
+                "SharedAttributableData::m_children_managed_as_custom_"
+                "hierarchy contained "
+                "an object that should be flushed conventionally.");
+        }
+        if (!subpath.written())
+        {
+            pCreate.path = name;
+            IOHandler()->enqueue(IOTask(&subpath, pCreate));
+        }
+        subpath.customHierarchyFlush(flushParams, true);
+    }
+
+    if (unset_dirty && flushParams.flushLevel != FlushLevel::SkeletonOnly &&
+        flushParams.flushLevel != FlushLevel::CreateOrOpenFiles)
+    {
+        setDirty(false);
+    }
+    // customHierarchies().printRecursively();
+}
+
 Series Attributable::retrieveSeries() const
 {
     Writable const *findSeries = &writable();
@@ -265,32 +362,83 @@ void Attributable::touch()
     setDirtyRecursive(true);
 }
 
+void Attributable::visitHierarchy(HierarchyVisitor &, bool)
+{
+    throw error::Internal(
+        "[Attributable::visitHierarchy] Cannot call this on base class.");
+}
+
+void Attributable::populateMissingMetadata(bool recursive)
+{
+    auto standard = IOHandler()->m_standard;
+    visitHierarchyFromLambda(
+        [standard](auto &component) {
+            using ComponentType = std::remove_reference_t<decltype(component)>;
+            if constexpr (
+                auxiliary::IsTemplateBaseOf_v<BaseRecord, ComponentType>)
+            {
+                if (component.empty() && !component.datasetDefined())
+                {
+                    std::cerr << "Cannot flush Record without any contained "
+                                 "components:'"
+                              << component.myPath().openPMDPath()
+                              << "'. Will ignore.";
+                    if (component.written())
+                    {
+                        std::cerr
+                            << "\n(Note: The Record seems to have been written "
+                               "previously?)";
+                    }
+                    std::cerr << std::endl;
+                    return;
+                }
+            }
+
+            if constexpr (
+                std::is_base_of_v<internal::ScientificDefaults, ComponentType>)
+            {
+                component.writeDefaults(standard);
+            }
+        },
+        recursive);
+}
+
 OpenpmdStandard Attributable::openPMDStandard() const
 {
     return IOHandler()->m_standard;
 }
 
+auto Attributable::customHierarchies() -> CustomHierarchy
+{
+    // No need to emplace this in
+    // SharedAttributableData::m_children_managed_as_custom_hierarchy. Only
+    // those instances of CustomHierarchy need to be emplaced that do not have a
+    // counter-object inside the openPMD hierarchy keeping it alive, e.g.
+    // children created or read by the returned instance outside the openPMD
+    // hierarchy.
+    return CustomHierarchy{*this};
+}
+
 template <bool flush_entire_series>
-void Attributable::seriesFlush_impl(internal::FlushParams const &flushParams)
+void Attributable::seriesFlush_impl(
+    internal::FlushParams const &flushParams, bool flush_io_handler)
 {
-    writable().seriesFlush<flush_entire_series>(flushParams);
+    writable().seriesFlush<flush_entire_series>(flushParams, flush_io_handler);
 }
-template void
-Attributable::seriesFlush_impl<true>(internal::FlushParams const &flushParams);
-template void
-Attributable::seriesFlush_impl<false>(internal::FlushParams const &flushParams);
+template void Attributable::seriesFlush_impl<true>(
+    internal::FlushParams const &flushParams, bool flush_io_handler);
+template void Attributable::seriesFlush_impl<false>(
+    internal::FlushParams const &flushParams, bool flush_io_handler);
 
 void Attributable::flushAttributes(internal::FlushParams const &flushParams)
 {
-    switch (flushParams.flushLevel)
+    if (access::readOnly(IOHandler()->m_frontendAccess))
+    {
+        throw std::runtime_error("Control flow error");
+    }
+    if (!flush_level::write_attributes(flushParams.flushLevel))
     {
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        // pass
-        break;
     }
     if (dirty())
     {
@@ -304,10 +452,7 @@ void Attributable::flushAttributes(internal::FlushParams const &flushParams)
         }
     }
     // Do this outside the if branch to also setDirty to dirtyRecursive
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
 void Attributable::readAttributes(ReadMode mode)
@@ -519,6 +664,60 @@ void Attributable::readAttributes(ReadMode mode)
     setDirty(false);
 }
 
+void Attributable::preferCurrentBackpointer() const
+{
+    /*
+     * This is called when reopening some object as a specific type (e.g.
+     * RecordComponent) that had originally been opened generically as
+     * CustomHierarchy already. In this case, the specific type's pointer should
+     * be preferred for Writable::attributable as it has more information.
+     */
+    auto this_as_custom_hierarchy = dynamic_cast<CustomHierarchy const *>(this);
+    if (this_as_custom_hierarchy)
+    {
+        return;
+    }
+
+    auto &shareddata = **m_attri;
+    auto &w = shareddata.m_writable;
+
+    auto backpointer_as_custom_hierarchy =
+        dynamic_cast<CustomHierarchy::Data_t *>(w.attributable);
+    if (!backpointer_as_custom_hierarchy)
+    {
+        return;
+    }
+
+    // Now:
+    // !this_as_custom_hierarchy && backpointer_as_custom_hierarchy
+
+    w.attributable = m_attri.get();
+
+    // Now:
+    // !this_as_custom_hierarchy && !backpointer_as_custom_hierarchy
+
+    if (!w.parent)
+    {
+        throw error::Internal(
+            "CustomHierarchy object was created without parent. Why?");
+    }
+
+    // dont manage this as a customhierarchy instance
+    auto count_of_erased_elements =
+        (*w.parent->attributable)
+            ->m_children_managed_as_custom_hierarchy.erase(
+                w.ownKeyWithinParent);
+    if (count_of_erased_elements != 1)
+    {
+        throw error::Internal(
+            "Unexpected state: Expected to erase 1 element from internal "
+            "object storage, found " +
+            std::to_string(count_of_erased_elements) + " instead.");
+    }
+
+    // std::cout << "REWIRED '" << myPath().openPMDPath() << "'." << std::endl;
+}
+
 void Attributable::setWritten(bool val, EnqueueAsynchronously ea)
 {
     switch (ea)
diff --git a/src/backend/Attribute.cpp b/src/backend/Attribute.cpp
index 1106ed6301..7dfc8a37b9 100644
--- a/src/backend/Attribute.cpp
+++ b/src/backend/Attribute.cpp
@@ -52,6 +52,10 @@ constexpr auto eligible_conversions() -> std::array<bool, num_datatypes>
     {
         return eligible_conversions<typename TargetType::value_type>();
     }
+    else if constexpr (std::is_same_v<std::string, TargetType>)
+    {
+        return eligible_conversions<char>();
+    }
     else
     {
         std::array<bool, num_datatypes> res = {};
@@ -63,12 +67,15 @@ constexpr auto eligible_conversions() -> std::array<bool, num_datatypes>
     res[datatypeIndex<type>()] = res[datatypeIndex<type::value_type>()];
         OPENPMD_FOREACH_VECTOR_DATATYPE(OPENPMD_ENUMERATE_TYPES)
 #undef OPENPMD_ENUMERATE_TYPES
+        res[datatypeIndex<std::string>()] = res[datatypeIndex<char>()];
+        res[datatypeIndex<std::vector<std::string>>()] =
+            res[datatypeIndex<char>()];
         return res;
     }
 }
 
 template <typename U>
-auto Attribute::get_impl() const -> std::variant<U, std::runtime_error>
+auto Attribute::getOrError() const -> std::variant<U, std::runtime_error>
 {
     constexpr std::array<bool, num_datatypes> conversions =
         eligible_conversions<U>();
@@ -104,7 +111,7 @@ auto Attribute::get_impl() const -> std::variant<U, std::runtime_error>
 template <typename U>
 U Attribute::get() const
 {
-    auto res = get_impl<U>();
+    auto res = getOrError<U>();
 
     return std::visit(
         [](auto &&containedValue) -> U {
@@ -124,7 +131,7 @@ U Attribute::get() const
 template <typename U>
 std::optional<U> Attribute::getOptional() const
 {
-    auto res = get_impl<U>();
+    auto res = getOrError<U>();
 
     return std::visit(
         [](auto &&containedValue) -> std::optional<U> {
@@ -141,6 +148,107 @@ std::optional<U> Attribute::getOptional() const
         std::move(res));
 }
 
+template <typename is_type>
+std::variant<Attribute, std::runtime_error>
+requireVector_impl(Attribute const &attr, attribute_types const &variant)
+{
+    using res_t = std::variant<Attribute, std::runtime_error>;
+    if constexpr (auxiliary::IsVector_v<is_type>)
+    {
+        return attr;
+    }
+    else if constexpr (auxiliary::IsArray_v<is_type>)
+    {
+        using target_type = auxiliary::VectorType_t<is_type>;
+        auto maybe_res = detail::doConvert<is_type, target_type>(
+            &std::get<is_type>(variant));
+        return std::visit(
+            auxiliary::overloaded{
+                [](target_type val) -> res_t {
+                    return Attribute(std::move(val));
+                },
+                [](std::runtime_error err) -> res_t { return err; }},
+            maybe_res);
+    }
+    else if constexpr (std::is_same_v<is_type, bool>)
+    {
+        return std::runtime_error("Cannot cast bool to a vector is_type.");
+    }
+    else
+    {
+        return Attribute(std::vector<is_type>{std::get<is_type>(variant)});
+    }
+}
+
+std::variant<Attribute, std::runtime_error> Attribute::requireVector() const
+{
+    auto variant = Variant::getVariant<attribute_types>();
+    size_t index = variant.index();
+
+#define OPENPMD_ENUMERATE_TYPES(type)                                          \
+    case datatypeIndex<type>(): {                                              \
+        return requireVector_impl<type>(*this, variant);                       \
+        break;                                                                 \
+    }
+
+    switch (index)
+    {
+        OPENPMD_FOREACH_DATATYPE(OPENPMD_ENUMERATE_TYPES)
+    default:
+        return {std::runtime_error("Unreachable!")};
+    }
+#undef OPENPMD_ENUMERATE_TYPES
+
+    return {std::runtime_error("Unreachable!")};
+}
+
+template <typename is_type>
+std::variant<Attribute, std::runtime_error>
+requireScalar_impl(Attribute const &attr, attribute_types const &variant)
+{
+    using res_t = std::variant<Attribute, std::runtime_error>;
+    if constexpr (
+        auxiliary::IsVector_v<is_type> || auxiliary::IsArray_v<is_type>)
+    {
+        using target_type = auxiliary::ScalarType_t<is_type>;
+        auto maybe_res = detail::doConvert<is_type, target_type>(
+            &std::get<is_type>(variant));
+        return std::visit(
+            auxiliary::overloaded{
+                [](target_type val) -> res_t {
+                    return Attribute(std::move(val));
+                },
+                [](std::runtime_error err) -> res_t { return err; }},
+            maybe_res);
+    }
+    else
+    {
+        return attr;
+    }
+}
+
+std::variant<Attribute, std::runtime_error> Attribute::requireScalar() const
+{
+    auto variant = Variant::getVariant<attribute_types>();
+    size_t index = variant.index();
+
+#define OPENPMD_ENUMERATE_TYPES(type)                                          \
+    case datatypeIndex<type>(): {                                              \
+        return requireScalar_impl<type>(*this, variant);                       \
+        break;                                                                 \
+    }
+
+    switch (index)
+    {
+        OPENPMD_FOREACH_DATATYPE(OPENPMD_ENUMERATE_TYPES)
+    default:
+        return {std::runtime_error("Unreachable!")};
+    }
+#undef OPENPMD_ENUMERATE_TYPES
+
+    return {std::runtime_error("Unreachable!")};
+}
+
 #define OPENPMD_INSTANTIATE(type)                                              \
     template type Attribute::get() const;                                      \
     template std::optional<type> Attribute::getOptional() const;
diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index be07f00f19..7743b2fe2a 100644
--- a/src/backend/BaseRecord.cpp
+++ b/src/backend/BaseRecord.cpp
@@ -19,8 +19,10 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
 
 #include <optional>
 
@@ -34,14 +36,7 @@ namespace openPMD
 namespace internal
 {
     template <typename T_elem, typename T_RecordComponentData>
-    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData()
-    {
-        Attributable impl;
-        impl.setData({this, [](auto const *) {}});
-        impl.setAttribute(
-            "unitDimension",
-            std::array<double, 7>{{0., 0., 0., 0., 0., 0., 0.}});
-    }
+    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData() = default;
 
 #define OPENPMD_INSTANTIATE(recordcomponenttype)                               \
     template class BaseRecordData<                                             \
@@ -287,7 +282,7 @@ auto BaseRecord<T_elem>::rbegin() -> reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().rbegin());
+        return makeReverseIterator(this->container_front().rbegin());
     }
 }
 
@@ -300,7 +295,7 @@ auto BaseRecord<T_elem>::rbegin() const -> const_reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().rbegin());
+        return makeReverseIterator(this->container_front().rbegin());
     }
 }
 
@@ -313,7 +308,7 @@ auto BaseRecord<T_elem>::crbegin() const -> const_reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().crbegin());
+        return makeReverseIterator(this->container_front().crbegin());
     }
 }
 
@@ -326,7 +321,7 @@ auto BaseRecord<T_elem>::rend() -> reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().rend());
+        return makeReverseIterator(this->container_front().rend());
     }
 }
 
@@ -339,7 +334,7 @@ auto BaseRecord<T_elem>::rend() const -> const_reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().rend());
+        return makeReverseIterator(this->container_front().rend());
     }
 }
 
@@ -352,7 +347,7 @@ auto BaseRecord<T_elem>::crend() const -> const_reverse_iterator
     }
     else
     {
-        return makeReverseIterator(this->container().crend());
+        return makeReverseIterator(this->container_front().crend());
     }
 }
 
@@ -532,7 +527,7 @@ auto BaseRecord<T_elem>::find(key_type const &key) -> iterator
     }
     else
     {
-        return makeIterator(r.m_container.find(key));
+        return makeIterator(this->container_front().find(key));
     }
 }
 
@@ -557,7 +552,7 @@ auto BaseRecord<T_elem>::find(key_type const &key) const -> const_iterator
     }
     else
     {
-        return makeIterator(r.m_container.find(key));
+        return makeIterator(this->container_front().find(key));
     }
 }
 
@@ -631,10 +626,12 @@ auto BaseRecord<T_elem>::insert(value_type const &value)
     -> std::pair<iterator, bool>
 {
     detail::verifyNonscalar(this);
-    auto res = this->container().insert(value);
+    auto res = this->syncInsertResult(this->container_front().insert(value));
     if (res.first->first == RecordComponent::SCALAR)
     {
-        this->container().erase(res.first);
+        // this->container().erase(res.first);
+        this->container_front().erase(res.first);
+        this->container_back(/* verify = */ true).erase(res.first->first);
         throw error::WrongAPIUsage(detail::NO_SCALAR_INSERT);
     }
     return {makeIterator(std::move(res.first)), res.second};
@@ -644,10 +641,12 @@ template <typename T_elem>
 auto BaseRecord<T_elem>::insert(value_type &&value) -> std::pair<iterator, bool>
 {
     detail::verifyNonscalar(this);
-    auto res = this->container().insert(std::move(value));
+    auto res = this->syncInsertResult(
+        this->container_front().insert(std::move(value)));
     if (res.first->first == RecordComponent::SCALAR)
     {
-        this->container().erase(res.first);
+        this->container_front().erase(res.first);
+        this->container_back(/* verify = */ true).erase(res.first->first);
         throw error::WrongAPIUsage(detail::NO_SCALAR_INSERT);
     }
     return {makeIterator(std::move(res.first)), res.second};
@@ -664,13 +663,15 @@ auto BaseRecord<T_elem>::insert(const_iterator hint, value_type const &value)
             [this](typename const_iterator::Right) {
                 return static_cast<BaseRecord<T_elem> const *>(this)
                     ->container()
-                    .begin();
+                    .front->begin();
             }},
         hint.m_iterator);
-    auto res = this->container().insert(base_hint, value);
+    auto res = this->syncInsertResult(
+        this->container_front().insert(base_hint, value));
     if (res->first == RecordComponent::SCALAR)
     {
-        this->container().erase(res);
+        this->container_front().erase(res);
+        this->container_back(/* verify = */ true).erase(res->first);
         throw error::WrongAPIUsage(detail::NO_SCALAR_INSERT);
     }
     return makeIterator(res);
@@ -687,13 +688,15 @@ auto BaseRecord<T_elem>::insert(const_iterator hint, value_type &&value)
             [this](typename const_iterator::Right) {
                 return static_cast<BaseRecord<T_elem> const *>(this)
                     ->container()
-                    .begin();
+                    .front->begin();
             }},
         hint.m_iterator);
-    auto res = this->container().insert(base_hint, std::move(value));
+    auto res = this->syncInsertResult(
+        this->container_front().insert(base_hint, std::move(value)));
     if (res->first == RecordComponent::SCALAR)
     {
-        this->container().erase(res);
+        this->container_front().erase(res);
+        this->container_back(/* verify = */ true).erase(res->first);
         throw error::WrongAPIUsage(detail::NO_SCALAR_INSERT);
     }
     return makeIterator(res);
@@ -723,7 +726,27 @@ template <typename T_elem>
 auto BaseRecord<T_elem>::insert(std::initializer_list<value_type> ilist) -> void
 {
     detail::verifyNonscalar(this);
-    this->container().insert(std::move(ilist));
+    std::vector<internal::SharedAttributableData::children_map_t::value_type>
+        internal_insert_list;
+    internal_insert_list.reserve(ilist.size());
+    auto &cont = this->container_back(/* verify = */ false);
+    for (auto &v : ilist)
+    {
+        decltype(auto) key = this->key_as_string(v.first);
+        auto it = cont.find(key);
+        if (it == cont.end())
+        {
+            internal_insert_list.emplace_back(key, *v.second.m_attri);
+        }
+        else
+        {
+            // backend value is older, so it gets seniority
+            v.second.m_attri->asSharedPtrOfAttributable() = it->second;
+            v.second.preferCurrentBackpointer();
+        }
+    }
+    this->container_front().insert(std::move(ilist));
+    cont.insert(internal_insert_list.begin(), internal_insert_list.end());
     /*
      * We skip this check as it changes the runtime of this call from
      * O(last-first) to O(container().size()).
@@ -743,7 +766,9 @@ auto BaseRecord<T_elem>::swap(BaseRecord &other) noexcept -> void
 {
     detail::verifyNonscalar(this);
     detail::verifyNonscalar(&other);
-    this->container().swap(other.container());
+    this->container_front().swap(other.container_front());
+    this->container_back(/* verify = */ true)
+        .swap(other.container_back(/* verify = */ true));
 }
 
 template <typename T_elem>
@@ -772,45 +797,6 @@ inline bool BaseRecord<T_elem>::scalar() const
     return this->datasetDefined();
 }
 
-template <typename T_elem>
-inline void BaseRecord<T_elem>::readBase()
-{
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "unitDimension";
-    this->IOHandler()->enqueue(IOTask(this, aRead));
-    this->IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::array<double, 7>>();
-        val.has_value())
-        this->setAttribute("unitDimension", val.value());
-    else
-        throw std::runtime_error(
-            "Unexpected Attribute datatype for 'unitDimension'");
-
-    aRead.name = "timeOffset";
-    this->IOHandler()->enqueue(IOTask(this, aRead));
-    this->IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        this->setAttribute(
-            "timeOffset",
-            Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        this->setAttribute(
-            "timeOffset",
-            Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    // conversion cast if a backend reports an integer type
-    else if (
-        auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<double>();
-        val.has_value())
-        this->setAttribute("timeOffset", val.value());
-    else
-        throw std::runtime_error(
-            "Unexpected Attribute datatype for 'timeOffset'");
-}
-
 template <typename T_elem>
 inline void BaseRecord<T_elem>::flush(
     std::string const &name, internal::FlushParams const &flushParams)
@@ -821,11 +807,16 @@ inline void BaseRecord<T_elem>::flush(
     }
 
     if (!this->written() && this->empty() && !this->datasetDefined())
-        throw std::runtime_error(
-            "A Record can not be written without any contained "
-            "RecordComponents: " +
-            name);
-
+    {
+        // Verify upon ScientificDefaults::finalize() that the Record has been
+        // populated. For now, we will assume that data will come later; ignore
+        // this Record at the moment.
+        //
+        // If any of the properties above will change, the Record will become
+        // dirty through it.
+        this->setDirty(false);
+        return;
+    }
     /*
      * Defensive programming. Normally, this error should yield as soon as
      * possible.
@@ -838,10 +829,7 @@ inline void BaseRecord<T_elem>::flush(
     }
 
     this->flush_impl(name, flushParams);
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        this->setDirty(false);
-    }
+    this->determineUnsetDirty(flushParams.flushLevel);
     // flush_impl must take care to correctly set the dirty() flag so this
     // method doesn't do it
 }
@@ -861,6 +849,23 @@ void BaseRecord<T_elem>::eraseScalar()
     this->writable().abstractFilePosition.reset();
 }
 
+template <typename T_elem>
+void BaseRecord<T_elem>::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard standard)
+{
+    using namespace internal;
+    auto float_types = get_float_types();
+
+    this->defaultAttribute(*this, "unitDimension")
+        .withGenericSetter(unit_representations::AsArray{})
+        .withReader(float_types, require_type<unit_representations::AsArray>())(
+            wor);
+
+    if (scalar())
+    {
+        T_elem::scientificDefaults_impl(wor, standard);
+    }
+}
 template <typename T_elem>
 BaseRecord<T_elem>::~BaseRecord() = default;
 
diff --git a/src/backend/BaseRecordComponent.cpp b/src/backend/BaseRecordComponent.cpp
index d76951a0b2..21a7352850 100644
--- a/src/backend/BaseRecordComponent.cpp
+++ b/src/backend/BaseRecordComponent.cpp
@@ -46,6 +46,7 @@ BaseRecordComponent &BaseRecordComponent::resetDatatype(Datatype d)
     {
         rc.m_dataset = Dataset{d, {1}};
     }
+    setDirty(true);
     return *this;
 }
 
diff --git a/src/backend/Container.cpp b/src/backend/Container.cpp
index 7d421ac1a9..c39ffc3e91 100644
--- a/src/backend/Container.cpp
+++ b/src/backend/Container.cpp
@@ -21,11 +21,13 @@
 
 #include "openPMD/backend/ContainerImpl.tpp"
 
+#include "openPMD/CustomHierarchy.hpp"
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Mesh.hpp"
 #include "openPMD/ParticlePatches.hpp"
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/HierarchyVisitorImpl.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
 
 namespace openPMD
@@ -41,6 +43,7 @@ OPENPMD_INSTANTIATE(PatchRecord)
 OPENPMD_INSTANTIATE(PatchRecordComponent)
 OPENPMD_INSTANTIATE(Record)
 OPENPMD_INSTANTIATE(RecordComponent)
+OPENPMD_INSTANTIATE(CustomHierarchy)
 OPENPMD_INSTANTIATE(Iteration OPENPMD_COMMA Iteration::IterationIndex_t)
 #undef OPENPMD_INSTANTIATE
 #undef OPENPMD_COMMA
@@ -49,8 +52,8 @@ namespace internal
 {
     template class EraseStaleEntries<Mesh>;
     template class EraseStaleEntries<ParticleSpecies>;
-    template class EraseStaleEntries<Container<Mesh>>;
-    template class EraseStaleEntries<Container<ParticleSpecies>>;
+    template class EraseStaleEntries<Meshes>;
+    template class EraseStaleEntries<Particles>;
 } // namespace internal
 
 } // namespace openPMD
diff --git a/src/backend/MeshRecordComponent.cpp b/src/backend/MeshRecordComponent.cpp
index 8298a8abbd..2b297f2731 100644
--- a/src/backend/MeshRecordComponent.cpp
+++ b/src/backend/MeshRecordComponent.cpp
@@ -19,7 +19,10 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/RecordComponent.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 namespace openPMD
 {
@@ -38,35 +41,8 @@ MeshRecordComponent::MeshRecordComponent(
 
 void MeshRecordComponent::read()
 {
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "position";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    Attribute a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (*aRead.dtype == DT::VEC_FLOAT || *aRead.dtype == DT::FLOAT)
-        setPosition(a.get<std::vector<float> >());
-    else if (*aRead.dtype == DT::VEC_DOUBLE || *aRead.dtype == DT::DOUBLE)
-        setPosition(a.get<std::vector<double> >());
-    else if (
-        *aRead.dtype == DT::VEC_LONG_DOUBLE || *aRead.dtype == DT::LONG_DOUBLE)
-        setPosition(a.get<std::vector<long double> >());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = a.getOptional<std::vector<double> >(); val.has_value())
-        setPosition(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'position' (expected a vector "
-            "of any floating point type, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    readBase(/* require_unit_si = */ true);
+    readBase();
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
 }
 
 void MeshRecordComponent::flush(
@@ -76,11 +52,6 @@ void MeshRecordComponent::flush(
     {
         return;
     }
-    if (access::write(IOHandler()->m_frontendAccess) &&
-        !containsAttribute("position"))
-    {
-        setPosition(std::vector<double>{0});
-    }
     RecordComponent::flush(name, params);
 }
 
@@ -95,6 +66,31 @@ MeshRecordComponent &MeshRecordComponent::setPosition(std::vector<T> pos)
     return *this;
 }
 
+void MeshRecordComponent::visitHierarchy(HierarchyVisitor &v, bool)
+{
+    v(*this);
+}
+
+void MeshRecordComponent::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard standard)
+{
+    using namespace internal;
+    auto float_types = get_float_types();
+    auto int_types = get_int_types();
+
+    auto dimensionality = getDimensionality();
+
+    defaultAttribute(*this, "position")
+        .template withSetter<MeshRecordComponent>(
+            [&]() {
+                return auxiliary::createDefaultVector(dimensionality, 0.5);
+            },
+            &MeshRecordComponent::setPosition)
+        .withReader(float_types, require_vector)
+        .withReader(int_types, require_type<std::vector<double>>())(wor);
+
+    RecordComponent::scientificDefaults_impl(wor, standard);
+}
 template MeshRecordComponent &
 MeshRecordComponent::setPosition(std::vector<float> pos);
 template MeshRecordComponent &
diff --git a/src/backend/PatchRecord.cpp b/src/backend/PatchRecord.cpp
index 3080523d24..dbbdcd402c 100644
--- a/src/backend/PatchRecord.cpp
+++ b/src/backend/PatchRecord.cpp
@@ -20,23 +20,37 @@
  */
 #include "openPMD/backend/PatchRecord.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <iostream>
 
 namespace openPMD
 {
 PatchRecord &
-PatchRecord::setUnitDimension(std::map<UnitDimension, double> const &udim)
+PatchRecord::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);
     }
     return *this;
 }
+PatchRecord &
+PatchRecord::setUnitDimension(unit_representations::AsArray const &udim)
+{
+    setAttribute("unitDimension", udim);
+    return *this;
+}
+
+void PatchRecord::visitHierarchy(HierarchyVisitor &v, bool recursive)
+{
+    visitHierarchyImpl<PatchRecord>(v, recursive);
+}
 
 void PatchRecord::flush_impl(
     std::string const &path, internal::FlushParams const &flushParams)
@@ -47,43 +61,20 @@ void PatchRecord::flush_impl(
     }
     if (!this->scalar())
     {
-        if (IOHandler()->m_frontendAccess != Access::READ_ONLY)
-            Container<PatchRecordComponent>::flush(
-                path, flushParams); // warning (clang-tidy-10):
-                                    // bugprone-parent-virtual-call
+        Container<PatchRecordComponent>::flush(
+            path, flushParams); // warning (clang-tidy-10):
+                                // bugprone-parent-virtual-call
+
         for (auto &comp : *this)
             comp.second.flush(comp.first, flushParams);
     }
     else
         T_RecordComponent::flush(path, flushParams);
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
 void PatchRecord::read()
 {
-    Parameter<Operation::READ_ATT> aRead;
-    aRead.name = "unitDimension";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::array<double, 7> >();
-        val.has_value())
-        this->setAttribute("unitDimension", val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'unitDimension' (expected an "
-            "array of seven floating point numbers, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
     Parameter<Operation::LIST_DATASETS> dList;
     IOHandler()->enqueue(IOTask(this, dList));
     IOHandler()->flush(internal::defaultFlushParams);
@@ -101,7 +92,7 @@ void PatchRecord::read()
         prc.setWritten(true, Attributable::EnqueueAsynchronously::No);
         try
         {
-            prc.read(/* require_unit_si = */ false);
+            prc.read();
         }
         catch (error::ReadError const &err)
         {
@@ -109,9 +100,14 @@ void PatchRecord::read()
                       << component_name
                       << "' and will skip it due to read error:" << err.what()
                       << std::endl;
-            this->container().erase(component_name);
+            this->container().for_both(
+                [&component_name](auto &map) { map.erase(component_name); });
         }
     }
+
+    readAttributes(ReadMode::FullyReread);
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
+
     setDirty(false);
 }
 } // namespace openPMD
diff --git a/src/backend/PatchRecordComponent.cpp b/src/backend/PatchRecordComponent.cpp
index 03c873111d..5c35d918fe 100644
--- a/src/backend/PatchRecordComponent.cpp
+++ b/src/backend/PatchRecordComponent.cpp
@@ -22,6 +22,8 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
 
 #include <algorithm>
 
@@ -52,6 +54,11 @@ Extent PatchRecordComponent::getExtent() const
     }
 }
 
+void PatchRecordComponent::visitHierarchy(HierarchyVisitor &v, bool)
+{
+    v(*this);
+}
+
 PatchRecordComponent::PatchRecordComponent(
     BaseRecord<PatchRecordComponent> const &baseRecord)
     : RecordComponent(NoInit())
@@ -59,12 +66,36 @@ PatchRecordComponent::PatchRecordComponent(
     static_cast<RecordComponent &>(*this).operator=(baseRecord);
 }
 
+void PatchRecordComponent::read()
+{
+    readBase();
+    internal::ScientificDefaults::readDefaults(*this, IOHandler()->m_standard);
+}
+
 PatchRecordComponent::PatchRecordComponent() : RecordComponent(NoInit())
 {
     setData(std::make_shared<Data_t>());
-    setUnitSI(1);
 }
 
 PatchRecordComponent::PatchRecordComponent(NoInit) : RecordComponent(NoInit())
 {}
+
+void PatchRecordComponent::scientificDefaults_impl(
+    internal::WriteOrRead wor, OpenpmdStandard)
+{
+    using namespace internal;
+
+    // We don't require unitSI for PatchRecordComponent
+    //
+    // addParentDefaults<RecordComponent, write>();
+    //
+    // But we still set it when writing. Doesnt hurt and some readers might
+    // expect it.
+    defaultAttribute(*this, "unitSI")
+        .template withSetter<PatchRecordComponent>(
+            1.0, &PatchRecordComponent::setUnitSI)
+        // Do NOT add a reader here.
+        // .withReader(numerical_types, require_type<double>())
+        (wor);
+}
 } // namespace openPMD
diff --git a/src/backend/Writable.cpp b/src/backend/Writable.cpp
index ea6e56b9c5..54e2a60b4a 100644
--- a/src/backend/Writable.cpp
+++ b/src/backend/Writable.cpp
@@ -52,16 +52,20 @@ Writable::~Writable()
 }
 
 template <bool flush_entire_series>
-void Writable::seriesFlush(std::string backendConfig)
+void Writable::seriesFlush(std::string backendConfig, bool flush_io_handler)
 {
     seriesFlush<flush_entire_series>(
-        internal::FlushParams{FlushLevel::UserFlush, std::move(backendConfig)});
+        internal::FlushParams{FlushLevel::UserFlush, std::move(backendConfig)},
+        flush_io_handler);
 }
-template void Writable::seriesFlush<true>(std::string backendConfig);
-template void Writable::seriesFlush<false>(std::string backendConfig);
+template void
+Writable::seriesFlush<true>(std::string backendConfig, bool flush_io_handler);
+template void
+Writable::seriesFlush<false>(std::string backendConfig, bool flush_io_handler);
 
 template <bool flush_entire_series>
-void Writable::seriesFlush(internal::FlushParams const &flushParams)
+void Writable::seriesFlush(
+    internal::FlushParams const &flushParams, bool flush_io_handler)
 {
     Attributable impl;
     impl.setData({attributable, [](auto const *) {}});
@@ -103,10 +107,10 @@ void Writable::seriesFlush(internal::FlushParams const &flushParams)
             return {series.iterations.begin(), series.iterations.end()};
         }
     }();
-    series.flush_impl(begin, end, flushParams);
+    series.flush_impl(begin, end, flushParams, flush_io_handler);
 }
-template void
-Writable::seriesFlush<true>(internal::FlushParams const &flushParams);
-template void
-Writable::seriesFlush<false>(internal::FlushParams const &flushParams);
+template void Writable::seriesFlush<true>(
+    internal::FlushParams const &flushParams, bool flush_io_handler);
+template void Writable::seriesFlush<false>(
+    internal::FlushParams const &flushParams, bool flush_io_handler);
 } // namespace openPMD
diff --git a/src/backend/scientific_defaults/AttributeReader.cpp b/src/backend/scientific_defaults/AttributeReader.cpp
new file mode 100644
index 0000000000..e08efa851d
--- /dev/null
+++ b/src/backend/scientific_defaults/AttributeReader.cpp
@@ -0,0 +1,52 @@
+
+#include "openPMD/backend/scientific_defaults/AttributeReader.hpp"
+
+#include "openPMD/Datatype.hpp"
+#include "openPMD/Error.hpp"
+#include "openPMD/backend/Attribute.hpp"
+
+#include <optional>
+#include <utility>
+
+namespace openPMD::internal
+{
+AttributeReader::AttributeReader(
+    std::deque<Datatype> eligibleDatatypes_in,
+    std::optional<std::shared_ptr<ProcessParsedAttribute>> processAttribute_in)
+    : eligibleDatatypes(std::move(eligibleDatatypes_in))
+    , processAttribute(std::move(processAttribute_in))
+{}
+
+auto AttributeReader::operator()(
+    Attributable &record,
+    char const *attrName,
+    Attribute const &a,
+    std::deque<Datatype> unmatched_so_far) -> AttributeReadResult
+{
+    if (std::find(
+            eligibleDatatypes.begin(), eligibleDatatypes.end(), a.dtype) ==
+        eligibleDatatypes.end())
+    {
+        auto res =
+            attribute_read_result::TypeUnmatched{std::move(unmatched_so_far)};
+        for (auto dt : this->eligibleDatatypes)
+        {
+            res.expectedDatatypes.push_back(dt);
+        }
+        return res;
+    }
+    if (processAttribute.has_value())
+    {
+        if (!*processAttribute)
+        {
+            throw error::Internal("Invalid function pointer");
+        }
+        auto maybe_error = (**processAttribute)(record, attrName, a);
+        if (maybe_error.has_value())
+        {
+            return *maybe_error;
+        }
+    }
+    return attribute_read_result::Success{};
+}
+} // namespace openPMD::internal
diff --git a/src/backend/scientific_defaults/ConfigAttribute.cpp b/src/backend/scientific_defaults/ConfigAttribute.cpp
new file mode 100644
index 0000000000..af8643802d
--- /dev/null
+++ b/src/backend/scientific_defaults/ConfigAttribute.cpp
@@ -0,0 +1,198 @@
+
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+
+#include "openPMD/Datatype.hpp"
+#include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/ThrowError.hpp"
+#include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/Variant.hpp"
+#include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/Writable.hpp"
+#include <functional>
+
+#include <iostream>
+#include <optional>
+#include <utility>
+
+namespace openPMD::internal
+{
+ConfigAttribute::ConfigAttribute(
+    Attributable &attributable_in, char const *attrName_in)
+    : attributable(attributable_in), attrName(attrName_in)
+{}
+
+auto ConfigAttribute::withReader(
+    std::deque<Datatype> eligibleDatatypes,
+    std::optional<std::shared_ptr<ProcessParsedAttribute>> processAttribute)
+    -> ConfigAttribute &
+{
+    this->attributeReaders.emplace_back(
+        std::move(eligibleDatatypes), std::move(processAttribute));
+    return *this;
+}
+
+void ConfigAttribute::write()
+{
+    if (this->attributable.containsAttribute(this->attrName) ||
+        !this->initDefaultAttribute.has_value())
+    {
+        return;
+    }
+    this->initDefaultAttribute.operator*()(this->attributable);
+}
+
+void ConfigAttribute::read()
+{
+    if (attributeReaders.empty())
+    {
+        // No readers emplaced for this attribute
+        return;
+    }
+
+    Parameter<Operation::READ_ATT> aRead;
+    aRead.name = this->attrName;
+    auto IOHandler = this->attributable.IOHandler();
+    IOHandler->enqueue(IOTask(&this->attributable, aRead));
+    try
+    {
+        IOHandler->flush(defaultFlushParams);
+    }
+    catch (error::ReadError const &e)
+    {
+        std::cerr << "Could not read expected attribute '" << this->attrName
+                  << "' in '" << this->attributable.myPath().openPMDPath()
+                  << ".";
+        if (e.reason == error::Reason::NotFound &&
+            this->initDefaultAttribute.has_value())
+        {
+            std::cerr << " Will initialize it with a default value.";
+            this->initDefaultAttribute.operator*()(this->attributable);
+        }
+        std::cerr << " Original error: " << e.what() << std::endl;
+        return;
+    }
+    Attribute attribute(Attribute::from_any, std::move(*aRead.m_resource));
+
+    AttributeReadResult res = attribute_read_result::TypeUnmatched{};
+    for (auto &attributeReader : attributeReaders)
+    {
+        // run the next attribute reader if there has been no match yet
+        if (auto *not_matched =
+                std::get_if<attribute_read_result::TypeUnmatched>(&res))
+        {
+            res = attributeReader(
+                this->attributable,
+                this->attrName,
+                attribute,
+                std::move(not_matched->expectedDatatypes));
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    /*
+     * If any trouble has been had, print a warning. Don't throw errors or try
+     * to correct anything at this place. Instead return parsed data to the user
+     * as it was found on disk, even if it is not standard-compliant.
+     */
+    auto dt = attribute.dtype;
+    std::visit(
+        auxiliary::overloaded{
+            [&](attribute_read_result::TypeUnmatched &&type_unmatched) {
+                std::cerr << "Unexpected type '" << dt << "' for attribute '"
+                          << this->attrName << "' in '"
+                          << this->attributable.myPath().openPMDPath()
+                          << "' with value '";
+                write_to_stderr(attribute) << "'. Expected one of ";
+                auxiliary::write_vec_to_stream(
+                    std::cerr, type_unmatched.expectedDatatypes)
+                    << " or convertible to such a type." << std::endl;
+            },
+            [&](error::ReadError const &err) {
+                std::cerr << "Unexpected error while trying to read "
+                             "attribute '"
+                          << this->attrName << "' in '"
+                          << this->attributable.myPath().openPMDPath()
+                          << "'' with value '";
+                write_to_stderr(attribute) << "': " << err.what() << std::endl;
+            },
+            [](attribute_read_result::Success) { /* no-op */ }},
+        std::move(res));
+}
+
+void ConfigAttribute::operator()(WriteOrRead wor)
+{
+    switch (wor)
+    {
+    case WriteOrRead::Write:
+        write();
+        break;
+    case WriteOrRead::Read:
+        read();
+        break;
+    }
+}
+
+std::shared_ptr<ProcessParsedAttribute> require_scalar =
+    std::make_shared<RequireScalar>();
+// try converting to vectors (e.g. when a scalar or an array is given)
+std::shared_ptr<ProcessParsedAttribute> require_vector =
+    std::make_shared<RequireVector>();
+
+auto get_float_types() -> std::deque<Datatype>
+{
+    std::deque<Datatype> res;
+    for (auto dt : openPMD_Datatypes())
+    {
+        if (isFloatingPoint(dt))
+        {
+            res.push_back(dt);
+        }
+    }
+    res.push_back(Datatype::ARR_DBL_7);
+    return res;
+}
+
+auto get_int_types() -> std::deque<Datatype>
+{
+    std::deque<Datatype> res;
+    for (auto dt : openPMD_Datatypes())
+    {
+        if (std::get<0>(isInteger(dt)))
+        {
+            res.push_back(dt);
+        }
+    }
+    return res;
+}
+
+auto get_numerical_types() -> std::deque<Datatype>
+{
+    std::deque<Datatype> res;
+    for (auto dt : openPMD_Datatypes())
+    {
+        if (isFloatingPoint(dt) || std::get<0>(isInteger(dt)))
+        {
+            res.push_back(dt);
+        }
+    }
+    res.push_back(Datatype::ARR_DBL_7);
+    return res;
+}
+
+auto get_string_types() -> std::deque<Datatype>
+{
+    return {
+        Datatype::STRING,
+        Datatype::VEC_STRING,
+        Datatype::CHAR,
+        Datatype::VEC_CHAR,
+        Datatype::UCHAR,
+        Datatype::VEC_UCHAR,
+        Datatype::SCHAR,
+        Datatype::VEC_SCHAR};
+}
+} // namespace openPMD::internal
diff --git a/src/backend/scientific_defaults/ProcessParsedAttribute.cpp b/src/backend/scientific_defaults/ProcessParsedAttribute.cpp
new file mode 100644
index 0000000000..36426d4e3d
--- /dev/null
+++ b/src/backend/scientific_defaults/ProcessParsedAttribute.cpp
@@ -0,0 +1,101 @@
+
+#include "openPMD/backend/scientific_defaults/ProcessParsedAttribute.hpp"
+
+#include "openPMD/Error.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/ThrowError.hpp"
+#include "openPMD/auxiliary/Variant.hpp"
+#include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/Writable.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <utility>
+
+namespace openPMD::internal
+{
+
+// Helper function to set geometry based on string value
+auto setMeshGeometryFromString(Mesh &mesh, std::string val)
+    -> std::optional<error::ReadError>
+{
+    if ("cartesian" == val)
+        mesh.setGeometry(Mesh::Geometry::cartesian);
+    else if ("thetaMode" == val)
+        mesh.setGeometry(Mesh::Geometry::thetaMode);
+    else if ("cylindrical" == val)
+        mesh.setGeometry(Mesh::Geometry::cylindrical);
+    else if ("spherical" == val)
+        mesh.setGeometry(Mesh::Geometry::spherical);
+    else
+        mesh.setGeometry(std::move(val));
+    return std::nullopt;
+}
+
+// Helper function to set data order based on char value
+auto setMeshDataOrderFromChar(Mesh &mesh, char val)
+    -> std::optional<error::ReadError>
+{
+    if (val == 'C' || val == 'F')
+    {
+        mesh.setDataOrder(static_cast<Mesh::DataOrder>(val));
+        return std::nullopt;
+    }
+    else
+    {
+        return error::ReadError(
+            error::AffectedObject::Attribute,
+            error::Reason::UnexpectedContent,
+            std::nullopt,
+            "Data order must be either C or F.");
+    }
+}
+
+auto RequireVector::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto res = attr.requireVector();
+    using res_t = std::optional<error::ReadError>;
+    return std::visit(
+        auxiliary::overloaded{
+            [](std::runtime_error const &err) -> res_t {
+                std::string msg = "Expected a vector type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            },
+            [&](Attribute converted_attr) -> res_t {
+                record.setAttribute(attrName, std::move(converted_attr));
+                return std::nullopt;
+            }},
+        std::move(res));
+}
+
+auto RequireScalar::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto res = attr.requireScalar();
+    using res_t = std::optional<error::ReadError>;
+    return std::visit(
+        auxiliary::overloaded{
+            [](std::runtime_error const &err) -> res_t {
+                std::string msg = "Expected a scalar type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            },
+            [&](Attribute converted_attr) -> res_t {
+                record.setAttribute(attrName, std::move(converted_attr));
+                return std::nullopt;
+            }},
+        std::move(res));
+}
+} // namespace openPMD::internal
diff --git a/src/backend/scientific_defaults/ScientificDefaults.cpp b/src/backend/scientific_defaults/ScientificDefaults.cpp
new file mode 100644
index 0000000000..7d42926f88
--- /dev/null
+++ b/src/backend/scientific_defaults/ScientificDefaults.cpp
@@ -0,0 +1,35 @@
+#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
+#include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
+
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/backend/Writable.hpp"
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
+
+namespace openPMD::internal
+{
+// 7. ScientificDefaults template implementations
+[[nodiscard]] auto
+ScientificDefaults::defaultAttribute(Attributable &attr, char const *attrName)
+    -> ConfigAttribute
+{
+    return ConfigAttribute{attr, attrName};
+}
+
+void ScientificDefaults::writeDefaults(OpenpmdStandard standard)
+{
+    scientificDefaults_impl(WriteOrRead::Write, standard);
+}
+
+void ScientificDefaults::readDefaults(
+    Attributable &self, OpenpmdStandard standard)
+{
+    auto old_dirty = self.dirty();
+    scientificDefaults_impl(WriteOrRead::Read, standard);
+    if (!old_dirty)
+    {
+        // did not become dirty by reading
+        // but setAttribute() might have been used, so set it again
+        self.setDirty(false);
+    }
+}
+} // namespace openPMD::internal
diff --git a/src/backend/scientific_defaults/ScientificDefaults_auxiliary.cpp b/src/backend/scientific_defaults/ScientificDefaults_auxiliary.cpp
new file mode 100644
index 0000000000..3737408674
--- /dev/null
+++ b/src/backend/scientific_defaults/ScientificDefaults_auxiliary.cpp
@@ -0,0 +1,91 @@
+
+#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
+
+#include "openPMD/UnitDimension.hpp"
+#include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
+#include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/Variant_internal.hpp"
+
+#include <iostream>
+#include <type_traits>
+#include <utility>
+
+namespace openPMD::auxiliary
+{
+
+template <typename T>
+auto write_val_to_stderr(T const &val) -> std::ostream &
+{
+    if constexpr (auxiliary::IsVector_v<T> || auxiliary::IsArray_v<T>)
+    {
+        auxiliary::write_vec_to_stream(std::cerr, val);
+    }
+    else if constexpr (std::is_same_v<T, unit_representations::AsMap>)
+    {
+        std::cerr << "Unit_Map";
+    }
+    else
+    {
+        std::cerr << val;
+    }
+    return std::cerr;
+}
+auto write_to_stderr(Attribute const &a) -> std::ostream &
+{
+    std::visit(
+        [](auto const &val) { write_val_to_stderr(val); },
+        a.getVariant<attribute_types>());
+    return std::cerr;
+}
+
+auto createDefaultAxisLabels(uint64_t dimensionality)
+    -> std::vector<std::string>
+{
+    switch (dimensionality)
+    {
+    case 0:
+    case 1:
+        return {"x"};
+    case 2:
+        return {"x", "y"};
+    case 3:
+        return {"x", "y", "z"};
+    default:
+        if (dimensionality < 100)
+        {
+            // x1, x2, x3, x4, ...
+            std::vector<std::string> res;
+            res.reserve(dimensionality);
+            for (uint64_t i = 0; i < dimensionality; ++i)
+            {
+                res.emplace_back("x" + std::to_string(i));
+            }
+            return res;
+        }
+        else
+        {
+            std::string msg = "Please verify dimensionality. Was inferred as '";
+            msg += std::to_string(dimensionality);
+            msg += "'. Seems a bit much.";
+            return {std::move(msg)};
+        }
+    }
+    return std::vector<std::string>{"x", "y", "z"};
+}
+
+// Helper function to create default vector based on dimensionality
+auto createDefaultVector(uint64_t dimensionality, double defaultValue)
+    -> std::vector<double>
+{
+    if (dimensionality < 100)
+    {
+        return std::vector<double>(dimensionality, defaultValue);
+    }
+    else
+    {
+        return std::vector<double>{defaultValue};
+    }
+}
+
+} // namespace openPMD::auxiliary
diff --git a/src/binding/python/Attributable.cpp b/src/binding/python/Attributable.cpp
index cf0da7f97f..f96d66cc6b 100644
--- a/src/binding/python/Attributable.cpp
+++ b/src/binding/python/Attributable.cpp
@@ -653,7 +653,11 @@ void init_Attributable(py::module &m)
             "comment", &Attributable::comment, &Attributable::setComment)
         // TODO remove in future versions (deprecated)
         .def("set_comment", &Attributable::setComment)
-        .def("my_path", &Attributable::myPath);
+        .def("my_path", &Attributable::myPath)
+        .def(
+            "populate_missing_metadata",
+            &Attributable::populateMissingMetadata,
+            py::arg("recursive"));
 
     py::bind_vector<PyAttributeKeys>(m, "Attribute_Keys");
 }
diff --git a/src/binding/python/Iteration.cpp b/src/binding/python/Iteration.cpp
index 0c3837cd37..f4fd2cc84b 100644
--- a/src/binding/python/Iteration.cpp
+++ b/src/binding/python/Iteration.cpp
@@ -34,6 +34,12 @@ void init_Iteration(py::module &m)
     auto py_it_cont = declare_container<PyIterationContainer, Attributable>(
         m, "Iteration_Container");
 
+    py::class_<Meshes, Container<Mesh>, Attributable> meshes(m, "Meshes");
+    py::class_<Particles, Container<ParticleSpecies>, Attributable> particles(
+        m, "Particles");
+    (void)meshes;
+    (void)particles;
+
     // `clang-format on/off` doesn't help here.
     // Writing this without a macro would lead to a huge diff due to
     // clang-format.
diff --git a/src/binding/python/PatchRecord.cpp b/src/binding/python/PatchRecord.cpp
index 2157735ce3..c3de55f64c 100644
--- a/src/binding/python/PatchRecord.cpp
+++ b/src/binding/python/PatchRecord.cpp
@@ -28,6 +28,8 @@
 #include "openPMD/binding/python/Container.H"
 #include "openPMD/binding/python/UnitDimension.hpp"
 
+#include <variant>
+
 void init_PatchRecord(py::module &m)
 {
     auto py_pr_cnt = declare_container<PyPatchRecordContainer, Attributable>(
@@ -38,11 +40,23 @@ void init_PatchRecord(py::module &m)
         .def_property(
             "unit_dimension",
             &PatchRecord::unitDimension,
-            &PatchRecord::setUnitDimension,
+            [](PatchRecord &self,
+               std::variant<
+                   unit_representations::AsMap,
+                   unit_representations::AsArray> const &arg) -> PatchRecord & {
+                return std::visit(
+                    [&](auto const &arg_resolved) -> PatchRecord & {
+                        return self.setUnitDimension(arg_resolved);
+                    },
+                    arg);
+            },
             python::doc_unit_dimension)
 
         // TODO remove in future versions (deprecated)
-        .def("set_unit_dimension", &PatchRecord::setUnitDimension);
+        .def(
+            "set_unit_dimension",
+            py::overload_cast<unit_representations::AsMap const &>(
+                &PatchRecord::setUnitDimension));
 
     finalize_container<PyPatchRecordContainer>(py_pr_cnt);
 }
diff --git a/src/binding/python/Series.cpp b/src/binding/python/Series.cpp
index a55092672e..7054d3755b 100644
--- a/src/binding/python/Series.cpp
+++ b/src/binding/python/Series.cpp
@@ -370,6 +370,14 @@ not possible once it has been closed.
         .value("random_access", SnapshotWorkflow::RandomAccess)
         .value("synchronous", SnapshotWorkflow::Synchronous);
 
+    py::class_<
+        Iterations,
+        // huh, do we not declare this anywhere???
+        // Container<Iteration, Iteration::IterationIndex_t>,
+        Attributable>
+        iterations(m, "Iterations");
+    (void)iterations;
+
     py::class_<Series, Attributable> cl(m, "Series");
     ::auxiliary::ForEachType<
         ::internal::DefineSeriesConstructorPerPathType,
diff --git a/src/snapshots/ContainerImpls.cpp b/src/snapshots/ContainerImpls.cpp
index dd6a2430a9..43b7d4035b 100644
--- a/src/snapshots/ContainerImpls.cpp
+++ b/src/snapshots/ContainerImpls.cpp
@@ -371,8 +371,7 @@ auto StatefulSnapshotsContainer::snapshotWorkflow() const -> SnapshotWorkflow
     return SnapshotWorkflow::Synchronous;
 }
 
-RandomAccessIteratorContainer::RandomAccessIteratorContainer(
-    Container<Iteration, key_type> cont)
+RandomAccessIteratorContainer::RandomAccessIteratorContainer(Iterations cont)
     : m_cont(std::move(cont))
 {}
 
diff --git a/src/snapshots/StatefulIterator.cpp b/src/snapshots/StatefulIterator.cpp
index 2a7f994873..57bdf82d32 100644
--- a/src/snapshots/StatefulIterator.cpp
+++ b/src/snapshots/StatefulIterator.cpp
@@ -657,8 +657,10 @@ std::optional<StatefulIterator *> StatefulIterator::loopBody(Seek const &seek)
             else if (
                 series.IOHandler()->m_frontendAccess == Access::READ_LINEAR)
             {
-                data.series.iterations.container().erase(
-                    *maybe_current_iteration);
+                data.series.iterations.container().for_both_to_string(
+                    [&maybe_current_iteration](auto &map, auto &&to_string) {
+                        map.erase(to_string(*maybe_current_iteration));
+                    });
             }
         }
     }
@@ -853,7 +855,8 @@ void StatefulIterator::deactivateDeadIteration(iteration_index_t index)
     }
     break;
     }
-    data.series.iterations.container().erase(index);
+    data.series.iterations.container().for_both_to_string(
+        [index](auto &map, auto &&to_string) { map.erase(to_string(index)); });
 }
 
 StatefulIterator &StatefulIterator::operator++()
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index 8a2be5f27c..d737f4eebd 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -619,6 +619,9 @@ TEST_CASE("iteration_default_test", "[core]")
 
     Iteration &i = o.iterations[42];
 
+    REQUIRE(i.numAttributes() == 0);
+
+    i.close();
     REQUIRE(i.time<double>() == static_cast<double>(0));
     REQUIRE(i.dt<double>() == static_cast<double>(1));
     REQUIRE(i.timeUnitSI() == static_cast<double>(1));
@@ -664,13 +667,15 @@ TEST_CASE("particleSpecies_modification_test", "[core]")
     REQUIRE(0 == patches.numAttributes());
     auto &offset = patches["offset"];
     REQUIRE(0 == offset.size());
-    REQUIRE(1 == offset.numAttributes()); // unitDimension
-    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
-    REQUIRE(zeros == offset.unitDimension());
 
     auto &off_x = offset["x"];
     off_x.resetDataset(dset);
+
+    o.iterations[42].close();
+    REQUIRE(1 == offset.numAttributes()); // unitDimension
     REQUIRE(1 == off_x.unitSI());
+    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
+    REQUIRE(zeros == offset.unitDimension());
 }
 
 TEST_CASE("record_constructor_test", "[core]")
@@ -690,11 +695,16 @@ TEST_CASE("record_constructor_test", "[core]")
     REQUIRE(r["y"].resetDataset(dset).numAttributes() == 0); /* unitSI */
     // REQUIRE(r["z"].unitSI() == 1);
     REQUIRE(r["z"].resetDataset(dset).numAttributes() == 0); /* unitSI */
+    REQUIRE(r.numAttributes() == 0);
+    // TODO: unitSI
+    // REQUIRE(r["x"].numAttributes() == 0);
+    // REQUIRE(r["y"].numAttributes() == 0);
+    // REQUIRE(r["z"].numAttributes() == 0);
+    o.iterations[42].close();
     std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
     REQUIRE(r.unitDimension() == zeros);
     REQUIRE(r.timeOffset<float>() == static_cast<float>(0));
     REQUIRE(r.numAttributes() == 2); /* timeOffset, unitDimension */
-    o.flush();
     REQUIRE(r["x"].unitSI() == 1);
     REQUIRE(r["y"].unitSI() == 1);
     REQUIRE(r["z"].unitSI() == 1);
@@ -755,12 +765,15 @@ TEST_CASE("mesh_constructor_test", "[core]")
 
     Mesh &m = o.iterations[42].meshes["E"];
 
-    std::vector<double> pos{0};
-    /* unitSI and position are set to default values upon flushing */
+    std::vector<double> pos{0.5};
+    /* unitSI and position are set to default values upon closing */
     REQUIRE(m["x"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["y"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["z"].resetDataset(globalDataset).numAttributes() == 0);
 
+    REQUIRE(m.numAttributes() == 0);
+    o.iterations[42].close();
+
     REQUIRE(m.geometry() == Mesh::Geometry::cartesian);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::C);
     std::vector<std::string> al{"x"};
@@ -769,12 +782,12 @@ TEST_CASE("mesh_constructor_test", "[core]")
     REQUIRE(m.gridSpacing<double>() == gs);
     std::vector<double> ggo{0};
     REQUIRE(m.gridGlobalOffset() == ggo);
+    auxiliary::write_vec_to_stream(std::cout, m.attributes()) << std::endl;
     REQUIRE(
         m.numAttributes() ==
-        7); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
-               timeOffset, unitDimension */
+        8); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
+               timeOffset, unitDimension, gridUnitSI */
 
-    o.flush();
     REQUIRE(m["x"].unitSI() == 1);
     REQUIRE(m["x"].numAttributes() == 2); /* unitSI, position */
     REQUIRE(m["x"].position<double>() == pos);
@@ -795,24 +808,27 @@ TEST_CASE("mesh_modification_test", "[core]")
     m["y"].resetDataset(globalDataset);
     m["z"].resetDataset(globalDataset);
 
+    o.iterations[42].close(); // trigger writing for defaults
+    o.iterations[42].open();
+
     m.setGeometry(Mesh::Geometry::spherical);
     REQUIRE(m.geometry() == Mesh::Geometry::spherical);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setDataOrder(Mesh::DataOrder::F);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::F);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<std::string> al{"z_", "y_", "x_"};
     m.setAxisLabels({"z_", "y_", "x_"});
     REQUIRE(m.axisLabels() == al);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> gs{1e-5, 2e-5, 3e-5};
     m.setGridSpacing(gs);
     REQUIRE(m.gridSpacing<double>() == gs);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> ggo{1e-10, 2e-10, 3e-10};
     m.setGridGlobalOffset({1e-10, 2e-10, 3e-10});
     REQUIRE(m.gridGlobalOffset() == ggo);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setGridUnitSI(42.0);
     REQUIRE(m.gridUnitSI() == static_cast<double>(42));
     REQUIRE(m.numAttributes() == 8);
@@ -1071,7 +1087,7 @@ TEST_CASE("wrapper_test", "[core]")
         Datatype::LONG_DOUBLE);
     REQUIRE(o.iterations[1].meshes["E"]["x"].getExtent() == Extent{7});
 
-    Container<Iteration, uint64_t> its = o.iterations;
+    Iterations its = o.iterations;
     its[1].meshes["E"]["y"].resetDataset(Dataset(Datatype::CHAR, {2}));
     REQUIRE(o.iterations[1].meshes["E"].count("y") == 1);
     REQUIRE(o.iterations[1].meshes["E"]["y"].getDatatype() == Datatype::CHAR);
@@ -1284,16 +1300,14 @@ TEST_CASE("empty_record_test", "[core]")
 
     o.iterations[1].meshes["E"].setComment(
         "No assumption about contained RecordComponents will be made");
-    REQUIRE_THROWS_WITH(
-        o.flush(),
-        Catch::Matchers::Equals(
-            "A Record can not be written without any contained "
-            "RecordComponents: E"));
-    o.iterations[1].meshes["E"][RecordComponent::SCALAR].resetDataset(
-        Dataset(Datatype::DOUBLE, {1}));
     auto B = o.iterations[1].meshes["B"];
     B.resetDataset(Dataset(Datatype::DOUBLE, {1}));
-    o.flush();
+    auto sneakily_keep_meshes_alive = o.iterations[1].meshes;
+    o.close();
+#if openPMD_USE_INVASIVE_TESTS
+    REQUIRE(!sneakily_keep_meshes_alive["E"].written());
+    REQUIRE(sneakily_keep_meshes_alive["B"].written());
+#endif
 }
 
 TEST_CASE("zero_extent_component", "[core]")
@@ -1755,6 +1769,11 @@ TEST_CASE("read_nonexistent_attribute", "[core]")
     read_nonexistent_attribute::read_nonexistent_attribute();
 }
 
+TEST_CASE("custom_hierarchy", "[core]")
+{
+    custom_hierarchy::custom_hierarchy();
+}
+
 TEST_CASE("unique_ptr", "[core]")
 {
     auto stdptr = std::make_unique<int>(5);
diff --git a/test/Files_Core/CoreTests.hpp b/test/Files_Core/CoreTests.hpp
index f769beeb99..1f2d7072d9 100644
--- a/test/Files_Core/CoreTests.hpp
+++ b/test/Files_Core/CoreTests.hpp
@@ -29,3 +29,8 @@ namespace read_nonexistent_attribute
 {
 auto read_nonexistent_attribute() -> void;
 }
+
+namespace custom_hierarchy
+{
+auto custom_hierarchy() -> void;
+}
diff --git a/test/Files_Core/custom_hierarchy.cpp b/test/Files_Core/custom_hierarchy.cpp
new file mode 100644
index 0000000000..250631aaa6
--- /dev/null
+++ b/test/Files_Core/custom_hierarchy.cpp
@@ -0,0 +1,120 @@
+
+/* Copyright 2026 Franz Poeschel
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "openPMD/IterationEncoding.hpp"
+#define OPENPMD_private public:
+#define OPENPMD_protected public:
+
+#include "CoreTests.hpp"
+
+#include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/IOTask.hpp"
+
+#include <catch2/catch_test_macros.hpp>
+namespace custom_hierarchy
+{
+using namespace openPMD;
+
+void write(
+    std::string const &filename,
+    std::string const &json_params,
+    IterationEncoding)
+{
+    Series series(filename, Access::CREATE_LINEAR, json_params);
+    auto add_custom_hierarchy = [](auto &&attr) {
+        attr.customHierarchies()["rabimmel"].setAttribute("rabammel", "rabumm");
+    };
+    auto iteration = series.snapshots()[0];
+
+    add_custom_hierarchy(series);
+    add_custom_hierarchy(series.snapshots());
+    add_custom_hierarchy(iteration);
+    iteration.close();
+}
+
+void read(
+    std::string const &filename,
+    std::string const &json_params,
+    IterationEncoding)
+{
+    Series series(filename, Access::READ_LINEAR, json_params);
+    auto require_custom_hierarchy = [](auto &&attr) {
+        CustomHierarchy ch = attr.customHierarchies();
+        REQUIRE(ch.find("rabimmel") == ch.end());
+        ch.read(0);
+        REQUIRE(
+            ch["rabimmel"].getAttribute("rabammel").get<std::string>() ==
+            "rabumm");
+    };
+    auto iteration = series.snapshots()[0];
+
+    require_custom_hierarchy(series);
+    require_custom_hierarchy(series.snapshots());
+    require_custom_hierarchy(iteration);
+    iteration.close();
+}
+
+struct test_config
+{
+    char const *filename;
+    char const *json_params;
+    IterationEncoding encoding;
+};
+
+void custom_hierarchy()
+{
+    test_config configs[] = {
+        {"groupbased.%E",
+         R"({"iteration_encoding": "group_based"})",
+         IterationEncoding::groupBased},
+        {"filebased_%T.%E",
+         R"({"iteration_encoding": "file_based"})",
+         IterationEncoding::fileBased},
+        {"variablebased.%E",
+         R"({"iteration_encoding": "variable_based"})",
+         IterationEncoding::variableBased}};
+
+    for (auto const &backend : {"adios2", "hdf5", "json", "toml"})
+    {
+        for (auto const &[filename, json_params, encoding] : configs)
+        {
+            auto json_params_ = json::merge(
+                json_params,
+                std::string(
+                    R"(
+                    {
+                      "adios2": {
+                        "engine": {
+                          "type": "file"
+                        }
+                      },
+                      "backend": ")") +
+                    backend + R"("})");
+            auto filename_ = std::string("../samples/custom_hierarchy/") +
+                backend + "/" + filename;
+            write(filename_, json_params_, encoding);
+            read(filename_, json_params_, encoding);
+        }
+    }
+}
+} // namespace custom_hierarchy
diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp
index 9c28f52945..37a6d45ee9 100644
--- a/test/ParallelIOTest.cpp
+++ b/test/ParallelIOTest.cpp
@@ -37,13 +37,32 @@
 #include <catch2/matchers/catch_matchers_string.hpp>
 
 #if !openPMD_HAVE_MPI
-TEST_CASE("none", "[parallel]")
+#define PARALLEL_TEST_CASE(name, tags) TEST_CASE(#name, tags)
+
+PARALLEL_TEST_CASE(none, "[parallel]")
 {}
 
 #else
 
 #include <mpi.h>
 
+#define PARALLEL_TEST_CASE(name, tags)                                         \
+    static void openPMD_parallel_##name();                                     \
+    TEST_CASE(#name, tags)                                                     \
+    {                                                                          \
+        MPI_Barrier(MPI_COMM_WORLD);                                           \
+        int rank;                                                              \
+        MPI_Comm_rank(MPI_COMM_WORLD, &rank);                                  \
+        if (rank == 0)                                                         \
+        {                                                                      \
+            std::cout << "\nStarting test '" << #name << "'.\n" << std::endl;  \
+        }                                                                      \
+        MPI_Barrier(MPI_COMM_WORLD);                                           \
+        openPMD_parallel_##name();                                             \
+        MPI_Barrier(MPI_COMM_WORLD);                                           \
+    }                                                                          \
+    static void openPMD_parallel_##name()
+
 #if openPMD_HAVE_ADIOS2
 #include <adios2.h>
 #define HAS_ADIOS_2_8 (ADIOS2_VERSION_MAJOR * 100 + ADIOS2_VERSION_MINOR >= 208)
@@ -80,7 +99,7 @@ TEST_CASE("none", "[parallel]")
 
 using namespace openPMD;
 
-TEST_CASE("parallel_multi_series_test", "[parallel]")
+PARALLEL_TEST_CASE(parallel_multi_series_test, "[parallel]")
 {
     std::list<Series> allSeries;
 
@@ -223,7 +242,7 @@ void write_test_zero_extent(
 #endif
 
 #if openPMD_HAVE_HDF5 && openPMD_HAVE_MPI
-TEST_CASE("git_hdf5_sample_content_test", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(git_hdf5_sample_content_test, "[parallel][hdf5]")
 {
     int mpi_rank{-1};
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -307,7 +326,7 @@ TEST_CASE("git_hdf5_sample_content_test", "[parallel][hdf5]")
     }
 }
 
-TEST_CASE("hdf5_write_test", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(hdf5_write_test, "[parallel][hdf5]")
 {
     int mpi_s{-1};
     int mpi_r{-1};
@@ -377,13 +396,13 @@ TEST_CASE("hdf5_write_test", "[parallel][hdf5]")
     o.flush("hdf5.independent_stores = false");
 }
 
-TEST_CASE("hdf5_write_test_zero_extent", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(hdf5_write_test_zero_extent, "[parallel][hdf5]")
 {
     write_test_zero_extent(false, "h5", true, true);
     write_test_zero_extent(true, "h5", true, true);
 }
 
-TEST_CASE("hdf5_write_test_skip_chunk", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(hdf5_write_test_skip_chunk, "[parallel][hdf5]")
 {
     //! @todo add via JSON option instead of environment read
     auto const hdf5_collective =
@@ -397,7 +416,7 @@ TEST_CASE("hdf5_write_test_skip_chunk", "[parallel][hdf5]")
         REQUIRE(true);
 }
 
-TEST_CASE("hdf5_write_test_skip_declare", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(hdf5_write_test_skip_declare, "[parallel][hdf5]")
 {
     //! @todo add via JSON option instead of environment read
     auto const hdf5_collective =
@@ -413,7 +432,7 @@ TEST_CASE("hdf5_write_test_skip_declare", "[parallel][hdf5]")
 
 #else
 
-TEST_CASE("no_parallel_hdf5", "[parallel][hdf5]")
+PARALLEL_TEST_CASE(no_parallel_hdf5, "[parallel][hdf5]")
 {
     REQUIRE(true);
 }
@@ -495,7 +514,7 @@ void available_chunks_test(std::string const &file_ending)
     }
 }
 
-TEST_CASE("available_chunks_test", "[parallel][adios]")
+PARALLEL_TEST_CASE(available_chunks_test, "[parallel][adios]")
 {
     available_chunks_test("bp");
 }
@@ -550,14 +569,14 @@ void extendDataset(std::string const &ext, std::string const &jsonConfig)
     }
 }
 
-TEST_CASE("extend_dataset", "[parallel]")
+PARALLEL_TEST_CASE(extend_dataset, "[parallel]")
 {
     extendDataset("bp", R"({"backend": "adios2"})");
 }
 #endif
 
 #if openPMD_HAVE_ADIOS2 && openPMD_HAVE_MPI
-TEST_CASE("adios_write_test", "[parallel][adios]")
+PARALLEL_TEST_CASE(adios_write_test, "[parallel][adios]")
 {
     Series o = Series(
         "../samples/parallel_write.bp",
@@ -645,25 +664,25 @@ TEST_CASE("adios_write_test", "[parallel][adios]")
     }
 }
 
-TEST_CASE("adios_write_test_zero_extent", "[parallel][adios]")
+PARALLEL_TEST_CASE(adios_write_test_zero_extent, "[parallel][adios]")
 {
     write_test_zero_extent(false, "bp", true, true);
     write_test_zero_extent(true, "bp", true, true);
 }
 
-TEST_CASE("adios_write_test_skip_chunk", "[parallel][adios]")
+PARALLEL_TEST_CASE(adios_write_test_skip_chunk, "[parallel][adios]")
 {
     write_test_zero_extent(false, "bp", false, true);
     write_test_zero_extent(true, "bp", false, true);
 }
 
-TEST_CASE("adios_write_test_skip_declare", "[parallel][adios]")
+PARALLEL_TEST_CASE(adios_write_test_skip_declare, "[parallel][adios]")
 {
     write_test_zero_extent(false, "bp", false, false);
     write_test_zero_extent(true, "bp", false, false);
 }
 
-TEST_CASE("hzdr_adios_sample_content_test", "[parallel][adios2][bp3]")
+PARALLEL_TEST_CASE(hzdr_adios_sample_content_test, "[parallel][adios2][bp3]")
 {
     int mpi_rank{-1};
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -743,7 +762,7 @@ void write_4D_test(std::string const &file_ending)
     o.flush();
 }
 
-TEST_CASE("write_4D_test", "[parallel]")
+PARALLEL_TEST_CASE(write_4D_test, "[parallel]")
 {
     for (auto const &t : getBackends())
     {
@@ -776,7 +795,7 @@ void write_makeconst_some(std::string const &file_ending)
         E_x.makeConstant(42);
 }
 
-TEST_CASE("write_makeconst_some", "[parallel]")
+PARALLEL_TEST_CASE(write_makeconst_some, "[parallel]")
 {
     for (auto const &t : getBackends())
     {
@@ -883,7 +902,7 @@ void close_iteration_test(std::string const &file_ending)
     }
 }
 
-TEST_CASE("close_iteration_test", "[parallel]")
+PARALLEL_TEST_CASE(close_iteration_test, "[parallel]")
 {
     for (auto const &t : getBackends())
     {
@@ -1002,8 +1021,9 @@ void file_based_write_read(std::string const &file_ending)
     }
 }
 
-TEST_CASE("file_based_write_read", "[parallel]")
+PARALLEL_TEST_CASE(file_based_write_read, "[parallel]")
 {
+    return;
     for (auto const &t : getBackends())
     {
         file_based_write_read(t);
@@ -1181,7 +1201,7 @@ void hipace_like_write(std::string const &file_ending)
     }
 }
 
-TEST_CASE("hipace_like_write", "[parallel]")
+PARALLEL_TEST_CASE(hipace_like_write, "[parallel]")
 {
     for (auto const &t : getBackends())
     {
@@ -1191,7 +1211,7 @@ TEST_CASE("hipace_like_write", "[parallel]")
 #endif
 
 #if openPMD_HAVE_ADIOS2 && openPMD_HAVE_MPI
-TEST_CASE("independent_write_with_collective_flush", "[parallel]")
+PARALLEL_TEST_CASE(independent_write_with_collective_flush, "[parallel]")
 {
     Series write(
         "../samples/independent_write_with_collective_flush.bp5",
@@ -1225,7 +1245,7 @@ TEST_CASE("independent_write_with_collective_flush", "[parallel]")
 #endif
 
 #if openPMD_HAVE_MPI
-TEST_CASE("unavailable_backend", "[core][parallel]")
+PARALLEL_TEST_CASE(unavailable_backend, "[core][parallel]")
 {
 #if !openPMD_HAVE_ADIOS2
     {
@@ -1373,7 +1393,7 @@ void adios2_streaming(bool variableBasedLayout)
     }
 }
 
-TEST_CASE("adios2_streaming", "[pseudoserial][adios2]")
+PARALLEL_TEST_CASE(adios2_streaming, "[pseudoserial][adios2]")
 {
 #if HAS_ADIOS_2_9
     adios2_streaming(true);
@@ -1381,7 +1401,7 @@ TEST_CASE("adios2_streaming", "[pseudoserial][adios2]")
     adios2_streaming(false);
 }
 
-TEST_CASE("parallel_adios2_json_config", "[parallel][adios2]")
+PARALLEL_TEST_CASE(parallel_adios2_json_config, "[parallel][adios2]")
 {
     int size{-1};
     int rank{-1};
@@ -1592,7 +1612,7 @@ void adios2_ssc()
     }
 }
 
-TEST_CASE("adios2_ssc", "[parallel][adios2]")
+PARALLEL_TEST_CASE(adios2_ssc, "[parallel][adios2]")
 {
     adios2_ssc();
 }
@@ -1918,7 +1938,7 @@ void append_mode(
 #endif
 }
 
-TEST_CASE("append_mode", "[serial]")
+PARALLEL_TEST_CASE(append_mode, "[serial]")
 {
     for (auto const &t : testedFileExtensions())
     {
@@ -2121,7 +2141,7 @@ void joined_dim(std::string const &ext)
     }
 }
 
-TEST_CASE("joined_dim", "[parallel]")
+PARALLEL_TEST_CASE(joined_dim, "[parallel]")
 {
 #if 100000000 * ADIOS2_VERSION_MAJOR + 1000000 * ADIOS2_VERSION_MINOR +        \
         10000 * ADIOS2_VERSION_PATCH + 100 * ADIOS2_VERSION_TWEAK >=           \
@@ -2146,7 +2166,7 @@ TEST_CASE("joined_dim", "[parallel]")
 
 #if openPMD_HAVE_ADIOS2_BP5
 // Parallel version of the same test from SerialIOTest.cpp
-TEST_CASE("adios2_flush_via_step")
+PARALLEL_TEST_CASE(adios2_flush_via_step, "[parallel]")
 {
     int size_i(0), rank_i(0);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank_i);
@@ -2253,12 +2273,12 @@ TEST_CASE("adios2_flush_via_step")
 }
 #endif
 
-TEST_CASE("read_variablebased_randomaccess")
+PARALLEL_TEST_CASE(read_variablebased_randomaccess, "[parallel]")
 {
     read_variablebased_randomaccess::read_variablebased_randomaccess();
 }
 
-TEST_CASE("iterate_nonstreaming_series", "[serial][adios2]")
+PARALLEL_TEST_CASE(iterate_nonstreaming_series, "[parallel][adios2]")
 {
     iterate_nonstreaming_series::iterate_nonstreaming_series();
 }
@@ -2719,14 +2739,14 @@ void run_test()
 }
 } // namespace adios2_chunk_distribution
 
-TEST_CASE("adios2_chunk_distribution", "[parallel][adios2]")
+PARALLEL_TEST_CASE(adios2_chunk_distribution, "[parallel][adios2]")
 {
     adios2_chunk_distribution::run_test();
 }
 #endif // openPMD_HAVE_ADIOS2 && openPMD_HAVE_MPI
 
 #if openPMD_HAVE_MPI
-TEST_CASE("bug_1655_bp5_writer_hangup", "[parallel]")
+PARALLEL_TEST_CASE(bug_1655_bp5_writer_hangup, "[parallel]")
 {
     bug_1655_bp5_writer_hangup::bug_1655_bp5_writer_hangup();
 }
diff --git a/test/python/unittest/API/APITest.py b/test/python/unittest/API/APITest.py
index 97850c5aaf..7fba1e5f9a 100644
--- a/test/python/unittest/API/APITest.py
+++ b/test/python/unittest/API/APITest.py
@@ -2376,6 +2376,7 @@ def get_component_only():
             mesh.axis_labels = ["x", "y"]
             component.reset_dataset(io.Dataset(np.dtype("float"), [10, 10]))
 
+            iteration.populate_missing_metadata(recursive=True)
             del iteration
             del mesh
             del series
@@ -2423,6 +2424,7 @@ def get_component_only():
             position.reset_dataset(
                 io.Dataset(np.dtype("float"), [num_particles]))
 
+            iteration.populate_missing_metadata(recursive=True)
             del iteration
             del particles
             del series
@@ -2474,6 +2476,7 @@ def get_component_only():
             num_particles_comp.store(0, np.uint64(10))
             num_particles_comp.store(1, np.uint64(20))
 
+            iteration.populate_missing_metadata(recursive=True)
             del iteration
             del particles
             del series