diff --git a/include/podio/CollectionBranches.h b/include/podio/CollectionBranches.h
new file mode 100644
index 000000000..3ab3e8129
--- /dev/null
+++ b/include/podio/CollectionBranches.h
@@ -0,0 +1,23 @@
+#ifndef PODIO_COLLECTIONBRANCHES_H
+#define PODIO_COLLECTIONBRANCHES_H
+
+#include "TBranch.h"
+
+#include <string>
+#include <vector>
+
+namespace podio::root_utils {
+/// Small helper struct to collect all branches that are necessary to read or
+/// write a collection. Needed to cache the branch pointers and avoid having to
+/// get them from a TTree/TChain for every event.
+struct CollectionBranches {
+  TBranch* data{nullptr};
+  std::vector<TBranch*> refs{};
+  std::vector<TBranch*> vecs{};
+  std::vector<std::string> refNames{}; ///< The names of the relation branches
+  std::vector<std::string> vecNames{}; ///< The names of the vector member branches
+};
+
+} // namespace podio::root_utils
+
+#endif
diff --git a/include/podio/GenericParameters.h b/include/podio/GenericParameters.h
index 88d8953f4..55119a2e8 100644
--- a/include/podio/GenericParameters.h
+++ b/include/podio/GenericParameters.h
@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <iostream>
-#include <iterator>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -31,12 +30,6 @@ class RNTupleWriter;
 
 namespace podio {
 
-#if !defined(__CLING__)
-// cling doesn't really deal well (i.e. at all in this case) with the forward
-// declaration here and errors out, breaking e.g. python bindings.
-class ROOTReader;
-#endif
-
 /// The types which are supported in the GenericParameters
 using SupportedGenericDataTypes = std::tuple<int, float, std::string, double>;
 
@@ -112,10 +105,6 @@ class GenericParameters {
   template <typename T, typename = EnableIfValidGenericDataType<T>>
   std::vector<std::string> getKeys() const;
 
-  /// Get all the available values for a given type
-  template <typename T, typename = EnableIfValidGenericDataType<T>>
-  std::vector<std::vector<T>> getValues() const;
-
   /// erase all elements
   void clear() {
     _intMap.clear();
@@ -140,10 +129,6 @@ class GenericParameters {
   friend RNTupleWriter;
 #endif
 
-#if !defined(__CLING__)
-  friend ROOTReader;
-#endif
-
   /// Get a reference to the internal map for a given type
   template <typename T>
   const MapType<detail::GetVectorType<T>>& getMap() const {
@@ -258,17 +243,5 @@ std::vector<std::string> GenericParameters::getKeys() const {
   return keys;
 }
 
-template <typename T, typename>
-std::vector<std::vector<T>> GenericParameters::getValues() const {
-  std::vector<std::vector<T>> values;
-  {
-    auto& mtx = getMutex<T>();
-    const auto& map = getMap<T>();
-    std::lock_guard lock{mtx};
-    values.reserve(map.size());
-    std::transform(map.begin(), map.end(), std::back_inserter(values), [](const auto& pair) { return pair.second; });
-  }
-  return values;
-}
 } // namespace podio
 #endif
diff --git a/include/podio/RNTupleReader.h b/include/podio/RNTupleReader.h
index 057b9fcef..1cffa149f 100644
--- a/include/podio/RNTupleReader.h
+++ b/include/podio/RNTupleReader.h
@@ -1,6 +1,8 @@
 #ifndef PODIO_RNTUPLEREADER_H
 #define PODIO_RNTUPLEREADER_H
 
+#include "podio/CollectionBranches.h"
+#include "podio/ICollectionProvider.h"
 #include "podio/ROOTFrameData.h"
 #include "podio/SchemaEvolution.h"
 #include "podio/podioVersion.h"
diff --git a/include/podio/RNTupleWriter.h b/include/podio/RNTupleWriter.h
index d8a53ba43..ed0f3012c 100644
--- a/include/podio/RNTupleWriter.h
+++ b/include/podio/RNTupleWriter.h
@@ -1,11 +1,11 @@
 #ifndef PODIO_RNTUPLEWRITER_H
 #define PODIO_RNTUPLEWRITER_H
 
+#include "podio/CollectionBase.h"
 #include "podio/Frame.h"
 #include "podio/GenericParameters.h"
 #include "podio/SchemaEvolution.h"
 #include "podio/utilities/DatamodelRegistryIOHelpers.h"
-#include "podio/utilities/RootHelpers.h"
 
 #include "TFile.h"
 #include <ROOT/RNTuple.hxx>
@@ -102,42 +102,42 @@ class RNTupleWriter {
   checkConsistency(const std::vector<std::string>& collsToWrite, const std::string& category) const;
 
 private:
-  std::unique_ptr<ROOT::Experimental::RNTupleModel>
-  createModels(const std::vector<root_utils::StoreCollection>& collections);
-
-  /// Helper struct to group all the necessary information for one category.
-  struct CategoryInfo {
-    std::unique_ptr<ROOT::Experimental::RNTupleWriter> writer{nullptr}; ///< The RNTupleWriter for this category
-
-    // The following are assumed to run in parallel!
-    std::vector<uint32_t> ids{};                  ///< The ids of all collections
-    std::vector<std::string> names{};             ///< The names of all collections
-    std::vector<std::string> types{};             ///< The types of all collections
-    std::vector<short> subsetCollections{};       ///< The flags identifying the subcollections
-    std::vector<SchemaVersionT> schemaVersions{}; ///< The schema versions of all collections
-
-    // Storage for the keys & values of all the parameters of this category
-    // (resp. at least the current entry)
-    root_utils::ParamStorage<int> intParams{};
-    root_utils::ParamStorage<float> floatParams{};
-    root_utils::ParamStorage<double> doubleParams{};
-    root_utils::ParamStorage<std::string> stringParams{};
-  };
-  CategoryInfo& getCategoryInfo(const std::string& category);
-
   template <typename T>
-  void fillParams(const GenericParameters& params, CategoryInfo& catInfo, ROOT::Experimental::REntry* entry);
+  void fillParams(GenericParameters& params, ROOT::Experimental::REntry* entry);
 
-  template <typename T>
-  root_utils::ParamStorage<T>& getParamStorage(CategoryInfo& catInfo);
+  using StoreCollection = std::pair<const std::string&, podio::CollectionBase*>;
+  std::unique_ptr<ROOT::Experimental::RNTupleModel> createModels(const std::vector<StoreCollection>& collections);
+
+  std::unique_ptr<ROOT::Experimental::RNTupleModel> m_metadata{};
+  std::unique_ptr<ROOT::Experimental::RNTupleWriter> m_metadataWriter{};
 
   std::unique_ptr<TFile> m_file{};
 
   DatamodelDefinitionCollector m_datamodelCollector{};
 
-  std::unordered_map<std::string, CategoryInfo> m_categories{};
+  struct CollectionInfo {
+    std::vector<uint32_t> id{};
+    std::vector<std::string> name{};
+    std::vector<std::string> type{};
+    std::vector<short> isSubsetCollection{};
+    std::vector<SchemaVersionT> schemaVersion{};
+    std::unique_ptr<ROOT::Experimental::RNTupleWriter> writer{nullptr};
+  };
+  CollectionInfo& getCategoryInfo(const std::string& category);
+
+  std::unordered_map<std::string, CollectionInfo> m_categories{};
 
   bool m_finished{false};
+
+  std::vector<std::string> m_intkeys{}, m_floatkeys{}, m_doublekeys{}, m_stringkeys{};
+
+  std::vector<std::vector<int>> m_intvalues{};
+  std::vector<std::vector<float>> m_floatvalues{};
+  std::vector<std::vector<double>> m_doublevalues{};
+  std::vector<std::vector<std::string>> m_stringvalues{};
+
+  template <typename T>
+  std::pair<std::vector<std::string>&, std::vector<std::vector<T>>&> getKeyValueVectors();
 };
 
 } // namespace podio
diff --git a/include/podio/ROOTLegacyReader.h b/include/podio/ROOTLegacyReader.h
index 9383ca51b..c379eea1c 100644
--- a/include/podio/ROOTLegacyReader.h
+++ b/include/podio/ROOTLegacyReader.h
@@ -1,12 +1,13 @@
 #ifndef PODIO_ROOTLEGACYREADER_H
 #define PODIO_ROOTLEGACYREADER_H
 
+#include "podio/CollectionBranches.h"
 #include "podio/ROOTFrameData.h"
 #include "podio/podioVersion.h"
-#include "podio/utilities/RootHelpers.h"
 
 #include "TChain.h"
 
+#include <iostream>
 #include <memory>
 #include <string>
 #include <tuple>
@@ -113,7 +114,7 @@ class ROOTLegacyReader {
 private:
   std::pair<TTree*, unsigned> getLocalTreeAndEntry(const std::string& treename);
 
-  void createCollectionBranches(const std::vector<root_utils::CollectionWriteInfoT>& collInfo);
+  void createCollectionBranches(const std::vector<std::tuple<uint32_t, std::string, bool, unsigned int>>& collInfo);
 
   podio::GenericParameters readEventMetaData();
 
diff --git a/include/podio/ROOTReader.h b/include/podio/ROOTReader.h
index e6ecbd0e0..b14a08d17 100644
--- a/include/podio/ROOTReader.h
+++ b/include/podio/ROOTReader.h
@@ -1,13 +1,14 @@
 #ifndef PODIO_ROOTREADER_H
 #define PODIO_ROOTREADER_H
 
+#include "podio/CollectionBranches.h"
 #include "podio/ROOTFrameData.h"
 #include "podio/podioVersion.h"
 #include "podio/utilities/DatamodelRegistryIOHelpers.h"
-#include "podio/utilities/RootHelpers.h"
 
 #include "TChain.h"
 
+#include <iostream>
 #include <memory>
 #include <string>
 #include <string_view>
@@ -156,10 +157,6 @@ class ROOTReader {
   /// Read the parameters for the entry specified in the passed CategoryInfo
   GenericParameters readEntryParameters(CategoryInfo& catInfo, bool reloadBranches, unsigned int localEntry);
 
-  template <typename T>
-  static void readParams(CategoryInfo& catInfo, podio::GenericParameters& params, bool reloadBranches,
-                         unsigned int localEntry);
-
   /// Read the data entry specified in the passed CategoryInfo, and increase the
   /// counter afterwards. In case the requested entry is larger than the
   /// available number of entries, return a nullptr.
diff --git a/include/podio/ROOTWriter.h b/include/podio/ROOTWriter.h
index 5ee23835f..06aa61a46 100644
--- a/include/podio/ROOTWriter.h
+++ b/include/podio/ROOTWriter.h
@@ -1,9 +1,9 @@
 #ifndef PODIO_ROOTWRITER_H
 #define PODIO_ROOTWRITER_H
 
+#include "podio/CollectionBranches.h"
 #include "podio/CollectionIDTable.h"
 #include "podio/utilities/DatamodelRegistryIOHelpers.h"
-#include "podio/utilities/RootHelpers.h"
 
 #include "TFile.h"
 
@@ -100,34 +100,32 @@ class ROOTWriter {
   checkConsistency(const std::vector<std::string>& collsToWrite, const std::string& category) const;
 
 private:
+  using StoreCollection = std::pair<const std::string&, podio::CollectionBase*>;
+
+  // collectionID, collectionType, subsetCollection
+  // @note same as in rootUtils.h private header!
+  using CollectionInfoT = std::tuple<uint32_t, std::string, bool, unsigned int>;
+
   /// Helper struct to group together all necessary state to write / process a
   /// given category. Created during the first writing of a category
   struct CategoryInfo {
-    TTree* tree{nullptr};                                     ///< The TTree to which this category is written
-    std::vector<root_utils::CollectionBranches> branches{};   ///< The branches for this category
-    std::vector<root_utils::CollectionWriteInfoT> collInfo{}; ///< Collection info for this category
-    podio::CollectionIDTable idTable{};                       ///< The collection id table for this category
-    std::vector<std::string> collsToWrite{};                  ///< The collections to write for this category
-
-    // Storage for the keys & values of all the parameters of this category
-    // (resp. at least the current entry)
-    root_utils::ParamStorage<int> intParams{};
-    root_utils::ParamStorage<float> floatParams{};
-    root_utils::ParamStorage<double> doubleParams{};
-    root_utils::ParamStorage<std::string> stringParams{};
+    TTree* tree{nullptr};                                   ///< The TTree to which this category is written
+    std::vector<root_utils::CollectionBranches> branches{}; ///< The branches for this category
+    std::vector<CollectionInfoT> collInfo{};                ///< Collection info for this category
+    podio::CollectionIDTable idTable{};                     ///< The collection id table for this category
+    std::vector<std::string> collsToWrite{};                ///< The collections to write for this category
   };
 
   /// Initialize the branches for this category
-  void initBranches(CategoryInfo& catInfo, const std::vector<root_utils::StoreCollection>& collections,
+  void initBranches(CategoryInfo& catInfo, const std::vector<StoreCollection>& collections,
                     /*const*/ podio::GenericParameters& parameters);
 
   /// Get the (potentially uninitialized category information for this category)
   CategoryInfo& getCategoryInfo(const std::string& category);
 
-  static void resetBranches(CategoryInfo& categoryInfo, const std::vector<root_utils::StoreCollection>& collections);
-
-  /// Fill the parameter keys and values into the CategoryInfo storage
-  static void fillParams(CategoryInfo& catInfo, const GenericParameters& params);
+  static void resetBranches(std::vector<root_utils::CollectionBranches>& branches,
+                            const std::vector<ROOTWriter::StoreCollection>& collections,
+                            /*const*/ podio::GenericParameters* parameters);
 
   std::unique_ptr<TFile> m_file{nullptr};                       ///< The storage file
   std::unordered_map<std::string, CategoryInfo> m_categories{}; ///< All categories
diff --git a/include/podio/utilities/RootHelpers.h b/include/podio/utilities/RootHelpers.h
deleted file mode 100644
index 8e3118b4d..000000000
--- a/include/podio/utilities/RootHelpers.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#ifndef PODIO_UTILITIES_ROOTHELPERS_H
-#define PODIO_UTILITIES_ROOTHELPERS_H
-
-#include "TBranch.h"
-
-#include <string>
-#include <tuple>
-#include <vector>
-
-namespace podio {
-class CollectionBase;
-
-namespace root_utils {
-
-  // A collection of additional information that describes the collection: the
-  // collectionID, the collection (data) type, whether it is a subset
-  // collection, and its schema version
-  using CollectionWriteInfoT = std::tuple<uint32_t, std::string, bool, unsigned int>;
-  // for backwards compatibility
-  using CollectionInfoWithoutSchemaT = std::tuple<int, std::string, bool>;
-
-  /// A collection name and a base pointer grouped together for writing
-  using StoreCollection = std::tuple<const std::string&, podio::CollectionBase*>;
-
-  /// Small helper struct to collect all branches that are necessary to read or
-  /// write a collection. Needed to cache the branch pointers and avoid having to
-  /// get them from a TTree/TChain for every event.
-  struct CollectionBranches {
-    CollectionBranches() = default;
-    ~CollectionBranches() = default;
-    CollectionBranches(const CollectionBranches&) = delete;
-    CollectionBranches& operator=(const CollectionBranches&) = delete;
-    CollectionBranches(CollectionBranches&&) = default;
-    CollectionBranches& operator=(CollectionBranches&&) = default;
-
-    CollectionBranches(TBranch* dataBranch) : data(dataBranch) {
-    }
-
-    TBranch* data{nullptr};
-    std::vector<TBranch*> refs{};
-    std::vector<TBranch*> vecs{};
-    std::vector<std::string> refNames{}; ///< The names of the relation branches
-    std::vector<std::string> vecNames{}; ///< The names of the vector member branches
-  };
-
-  /// Pair of keys and values for one type of the ones that can be stored in
-  /// GenericParameters
-  template <typename T>
-  struct ParamStorage {
-    ParamStorage() = default;
-    ~ParamStorage() = default;
-    ParamStorage(const ParamStorage&) = delete;
-    ParamStorage& operator=(const ParamStorage&) = delete;
-    ParamStorage(ParamStorage&&) = default;
-    ParamStorage& operator=(ParamStorage&&) = default;
-
-    ParamStorage(const std::vector<std::string>& ks, const std::vector<std::vector<T>>& vs) : keys(ks), values(vs) {
-    }
-
-    auto keysPtr() {
-      m_keysPtr = &keys;
-      return &m_keysPtr;
-    }
-
-    auto valuesPtr() {
-      m_valuesPtr = &values;
-      return &m_valuesPtr;
-    }
-
-    std::vector<std::string> keys{};
-    std::vector<std::vector<T>> values{};
-
-  private:
-    std::vector<std::string>* m_keysPtr{nullptr};
-    std::vector<std::vector<T>>* m_valuesPtr{nullptr};
-  };
-
-} // namespace root_utils
-} // namespace podio
-
-#endif // PODIO_UTILITIES_ROOTHELPERS_H
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 561e2a9b9..393e93383 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -94,7 +94,6 @@ SET(root_headers
   ${PROJECT_SOURCE_DIR}/include/podio/ROOTLegacyReader.h
   ${PROJECT_SOURCE_DIR}/include/podio/ROOTWriter.h
   ${PROJECT_SOURCE_DIR}/include/podio/ROOTFrameData.h
-  ${PROJECT_SOURCE_DIR}/include/podio/utilities/RootHelpers.h
   )
 if(ENABLE_RNTUPLE)
   list(APPEND root_headers
diff --git a/src/RNTupleWriter.cc b/src/RNTupleWriter.cc
index 55d23167f..38231cc18 100644
--- a/src/RNTupleWriter.cc
+++ b/src/RNTupleWriter.cc
@@ -17,6 +17,7 @@
 namespace podio {
 
 RNTupleWriter::RNTupleWriter(const std::string& filename) :
+    m_metadata(ROOT::Experimental::RNTupleModel::Create()),
     m_file(new TFile(filename.c_str(), "RECREATE", "data file")) {
 }
 
@@ -27,35 +28,40 @@ RNTupleWriter::~RNTupleWriter() {
 }
 
 template <typename T>
-root_utils::ParamStorage<T>& RNTupleWriter::getParamStorage(CategoryInfo& catInfo) {
+std::pair<std::vector<std::string>&, std::vector<std::vector<T>>&> RNTupleWriter::getKeyValueVectors() {
   if constexpr (std::is_same_v<T, int>) {
-    return catInfo.intParams;
+    return {m_intkeys, m_intvalues};
   } else if constexpr (std::is_same_v<T, float>) {
-    return catInfo.floatParams;
+    return {m_floatkeys, m_floatvalues};
   } else if constexpr (std::is_same_v<T, double>) {
-    return catInfo.doubleParams;
+    return {m_doublekeys, m_doublevalues};
   } else if constexpr (std::is_same_v<T, std::string>) {
-    return catInfo.stringParams;
+    return {m_stringkeys, m_stringvalues};
   } else {
     throw std::runtime_error("Unknown type");
   }
 }
 
 template <typename T>
-void RNTupleWriter::fillParams(const GenericParameters& params, CategoryInfo& catInfo,
-                               ROOT::Experimental::REntry* entry) {
-  auto& paramStorage = getParamStorage<T>(catInfo);
-  auto& keys = paramStorage.keys;
-  auto& values = paramStorage.values;
-  keys = params.getKeys<T>();
-  values = params.getValues<T>();
+void RNTupleWriter::fillParams(GenericParameters& params, ROOT::Experimental::REntry* entry) {
+  auto [key, value] = getKeyValueVectors<T>();
 #if ROOT_VERSION_CODE >= ROOT_VERSION(6, 31, 0)
-  entry->BindRawPtr(root_utils::getGPKeyName<T>(), &keys);
-  entry->BindRawPtr(root_utils::getGPValueName<T>(), &values);
+  entry->BindRawPtr(root_utils::getGPKeyName<T>(), &key);
+  entry->BindRawPtr(root_utils::getGPValueName<T>(), &value);
 #else
-  entry->CaptureValueUnsafe(root_utils::getGPKeyName<T>(), &keys);
-  entry->CaptureValueUnsafe(root_utils::getGPValueName<T>(), &values);
+  entry->CaptureValueUnsafe(root_utils::getGPKeyName<T>(), &key);
+  entry->CaptureValueUnsafe(root_utils::getGPValueName<T>(), &value);
 #endif
+
+  key.clear();
+  key.reserve(params.getMap<T>().size());
+  value.clear();
+  value.reserve(params.getMap<T>().size());
+
+  for (auto& [kk, vv] : params.getMap<T>()) {
+    key.emplace_back(kk);
+    value.emplace_back(vv);
+  }
 }
 
 void RNTupleWriter::writeFrame(const podio::Frame& frame, const std::string& category) {
@@ -71,14 +77,14 @@ void RNTupleWriter::writeFrame(const podio::Frame& frame, const std::string& cat
   const bool new_category = (catInfo.writer == nullptr);
   if (new_category) {
     // This is the minimal information that we need for now
-    catInfo.names = root_utils::sortAlphabeticaly(collsToWrite);
+    catInfo.name = root_utils::sortAlphabeticaly(collsToWrite);
   }
 
-  std::vector<root_utils::StoreCollection> collections;
-  collections.reserve(catInfo.names.size());
+  std::vector<StoreCollection> collections;
+  collections.reserve(catInfo.name.size());
   // Only loop over the collections that were requested in the first Frame of
   // this category
-  for (const auto& name : catInfo.names) {
+  for (const auto& name : catInfo.name) {
     auto* coll = frame.getCollectionForWrite(name);
     if (!coll) {
       // Make sure all collections that we want to write are actually available
@@ -95,15 +101,15 @@ void RNTupleWriter::writeFrame(const podio::Frame& frame, const std::string& cat
     catInfo.writer = ROOT::Experimental::RNTupleWriter::Append(std::move(model), category, *m_file.get(), {});
 
     for (const auto& [name, coll] : collections) {
-      catInfo.ids.emplace_back(coll->getID());
-      catInfo.types.emplace_back(coll->getTypeName());
-      catInfo.subsetCollections.emplace_back(coll->isSubsetCollection());
-      catInfo.schemaVersions.emplace_back(coll->getSchemaVersion());
+      catInfo.id.emplace_back(coll->getID());
+      catInfo.type.emplace_back(coll->getTypeName());
+      catInfo.isSubsetCollection.emplace_back(coll->isSubsetCollection());
+      catInfo.schemaVersion.emplace_back(coll->getSchemaVersion());
     }
   } else {
-    if (!root_utils::checkConsistentColls(catInfo.names, collsToWrite)) {
+    if (!root_utils::checkConsistentColls(catInfo.name, collsToWrite)) {
       throw std::runtime_error("Trying to write category '" + category + "' with inconsistent collection content. " +
-                               root_utils::getInconsistentCollsMsg(catInfo.names, collsToWrite));
+                               root_utils::getInconsistentCollsMsg(catInfo.name, collsToWrite));
     }
   }
 
@@ -172,17 +178,17 @@ void RNTupleWriter::writeFrame(const podio::Frame& frame, const std::string& cat
     // &const_cast<podio::GenericParameters&>(frame.getParameters()));
   }
 
-  const auto& params = frame.getParameters();
-  fillParams<int>(params, catInfo, entry.get());
-  fillParams<float>(params, catInfo, entry.get());
-  fillParams<double>(params, catInfo, entry.get());
-  fillParams<std::string>(params, catInfo, entry.get());
+  auto params = frame.getParameters();
+  fillParams<int>(params, entry.get());
+  fillParams<float>(params, entry.get());
+  fillParams<double>(params, entry.get());
+  fillParams<std::string>(params, entry.get());
 
   m_categories[category].writer->Fill(*entry);
 }
 
 std::unique_ptr<ROOT::Experimental::RNTupleModel>
-RNTupleWriter::createModels(const std::vector<root_utils::StoreCollection>& collections) {
+RNTupleWriter::createModels(const std::vector<StoreCollection>& collections) {
   auto model = ROOT::Experimental::RNTupleModel::CreateBare();
 
 #if ROOT_VERSION_CODE >= ROOT_VERSION(6, 31, 0)
@@ -254,49 +260,49 @@ RNTupleWriter::createModels(const std::vector<root_utils::StoreCollection>& coll
   return model;
 }
 
-RNTupleWriter::CategoryInfo& RNTupleWriter::getCategoryInfo(const std::string& category) {
+RNTupleWriter::CollectionInfo& RNTupleWriter::getCategoryInfo(const std::string& category) {
   if (auto it = m_categories.find(category); it != m_categories.end()) {
     return it->second;
   }
 
-  auto [it, _] = m_categories.try_emplace(category, CategoryInfo{});
+  auto [it, _] = m_categories.try_emplace(category, CollectionInfo{});
   return it->second;
 }
 
 void RNTupleWriter::finish() {
-  auto metadata = ROOT::Experimental::RNTupleModel::Create();
 
   auto podioVersion = podio::version::build_version;
-  auto versionField = metadata->MakeField<std::vector<uint16_t>>(root_utils::versionBranchName);
+  auto versionField = m_metadata->MakeField<std::vector<uint16_t>>(root_utils::versionBranchName);
   *versionField = {podioVersion.major, podioVersion.minor, podioVersion.patch};
 
   auto edmDefinitions = m_datamodelCollector.getDatamodelDefinitionsToWrite();
-  auto edmField = metadata->MakeField<std::vector<std::tuple<std::string, std::string>>>(root_utils::edmDefBranchName);
+  auto edmField =
+      m_metadata->MakeField<std::vector<std::tuple<std::string, std::string>>>(root_utils::edmDefBranchName);
   *edmField = std::move(edmDefinitions);
 
-  auto availableCategoriesField = metadata->MakeField<std::vector<std::string>>(root_utils::availableCategories);
+  auto availableCategoriesField = m_metadata->MakeField<std::vector<std::string>>(root_utils::availableCategories);
   for (auto& [c, _] : m_categories) {
     availableCategoriesField->push_back(c);
   }
 
   for (auto& [category, collInfo] : m_categories) {
-    auto idField = metadata->MakeField<std::vector<unsigned int>>({root_utils::idTableName(category)});
-    *idField = collInfo.ids;
-    auto collectionNameField = metadata->MakeField<std::vector<std::string>>({root_utils::collectionName(category)});
-    *collectionNameField = collInfo.names;
-    auto collectionTypeField = metadata->MakeField<std::vector<std::string>>({root_utils::collInfoName(category)});
-    *collectionTypeField = collInfo.types;
-    auto subsetCollectionField = metadata->MakeField<std::vector<short>>({root_utils::subsetCollection(category)});
-    *subsetCollectionField = collInfo.subsetCollections;
-    auto schemaVersionField = metadata->MakeField<std::vector<SchemaVersionT>>({"schemaVersion_" + category});
-    *schemaVersionField = collInfo.schemaVersions;
+    auto idField = m_metadata->MakeField<std::vector<unsigned int>>({root_utils::idTableName(category)});
+    *idField = collInfo.id;
+    auto collectionNameField = m_metadata->MakeField<std::vector<std::string>>({root_utils::collectionName(category)});
+    *collectionNameField = collInfo.name;
+    auto collectionTypeField = m_metadata->MakeField<std::vector<std::string>>({root_utils::collInfoName(category)});
+    *collectionTypeField = collInfo.type;
+    auto subsetCollectionField = m_metadata->MakeField<std::vector<short>>({root_utils::subsetCollection(category)});
+    *subsetCollectionField = collInfo.isSubsetCollection;
+    auto schemaVersionField = m_metadata->MakeField<std::vector<SchemaVersionT>>({"schemaVersion_" + category});
+    *schemaVersionField = collInfo.schemaVersion;
   }
 
-  metadata->Freeze();
-  auto metadataWriter =
-      ROOT::Experimental::RNTupleWriter::Append(std::move(metadata), root_utils::metaTreeName, *m_file, {});
+  m_metadata->Freeze();
+  m_metadataWriter =
+      ROOT::Experimental::RNTupleWriter::Append(std::move(m_metadata), root_utils::metaTreeName, *m_file, {});
 
-  metadataWriter->Fill();
+  m_metadataWriter->Fill();
 
   m_file->Write();
 
@@ -305,6 +311,7 @@ void RNTupleWriter::finish() {
   for (auto& [_, catInfo] : m_categories) {
     catInfo.writer.reset();
   }
+  m_metadataWriter.reset();
 
   m_finished = true;
 }
@@ -312,7 +319,7 @@ void RNTupleWriter::finish() {
 std::tuple<std::vector<std::string>, std::vector<std::string>>
 RNTupleWriter::checkConsistency(const std::vector<std::string>& collsToWrite, const std::string& category) const {
   if (const auto it = m_categories.find(category); it != m_categories.end()) {
-    return root_utils::getInconsistentColls(it->second.names, collsToWrite);
+    return root_utils::getInconsistentColls(it->second.name, collsToWrite);
   }
 
   return {std::vector<std::string>{}, collsToWrite};
diff --git a/src/ROOTLegacyReader.cc b/src/ROOTLegacyReader.cc
index 494ec4301..c5815e4e3 100644
--- a/src/ROOTLegacyReader.cc
+++ b/src/ROOTLegacyReader.cc
@@ -138,7 +138,7 @@ void ROOTLegacyReader::openFiles(const std::vector<std::string>& filenames) {
   // Check if the CollectionTypeInfo branch is there and assume that the file
   // has been written with with podio pre #197 (<0.13.1) if that is not the case
   if (auto* collInfoBranch = root_utils::getBranch(metadatatree, "CollectionTypeInfo")) {
-    auto collectionInfo = new std::vector<root_utils::CollectionWriteInfoT>;
+    auto collectionInfo = new std::vector<root_utils::CollectionInfoT>;
 
     if (m_fileVersion < podio::version::Version{0, 16, 4}) {
       auto oldCollInfo = new std::vector<root_utils::CollectionInfoWithoutSchemaT>();
@@ -171,7 +171,7 @@ unsigned ROOTLegacyReader::getEntries(const std::string& name) const {
   return m_chain->GetEntries();
 }
 
-void ROOTLegacyReader::createCollectionBranches(const std::vector<root_utils::CollectionWriteInfoT>& collInfo) {
+void ROOTLegacyReader::createCollectionBranches(const std::vector<root_utils::CollectionInfoT>& collInfo) {
   size_t collectionIndex{0};
 
   for (const auto& [collID, collType, isSubsetColl, collSchemaVersion] : collInfo) {
@@ -207,7 +207,7 @@ void ROOTLegacyReader::createCollectionBranches(const std::vector<root_utils::Co
 
     m_storedClasses.emplace_back(name, std::make_tuple(collType, isSubsetColl, collSchemaVersion, collectionIndex++));
 
-    m_collectionBranches.emplace_back(std::move(branches));
+    m_collectionBranches.push_back(branches);
   }
 }
 
diff --git a/src/ROOTReader.cc b/src/ROOTReader.cc
index 3e786fb43..928000c7a 100644
--- a/src/ROOTReader.cc
+++ b/src/ROOTReader.cc
@@ -5,12 +5,13 @@
 #include "podio/CollectionIDTable.h"
 #include "podio/DatamodelRegistry.h"
 #include "podio/GenericParameters.h"
-#include "podio/utilities/RootHelpers.h"
 #include "rootUtils.h"
 
 // ROOT specific includes
 #include "TChain.h"
 #include "TClass.h"
+#include "TFile.h"
+#include "TTree.h"
 #include "TTreeCache.h"
 
 #include <stdexcept>
@@ -20,91 +21,28 @@ namespace podio {
 
 std::tuple<std::vector<root_utils::CollectionBranches>, std::vector<std::pair<std::string, detail::CollectionInfo>>>
 createCollectionBranches(TChain* chain, const podio::CollectionIDTable& idTable,
-                         const std::vector<root_utils::CollectionWriteInfoT>& collInfo);
+                         const std::vector<root_utils::CollectionInfoT>& collInfo);
 
 std::tuple<std::vector<root_utils::CollectionBranches>, std::vector<std::pair<std::string, detail::CollectionInfo>>>
 createCollectionBranchesIndexBased(TChain* chain, const podio::CollectionIDTable& idTable,
-                                   const std::vector<root_utils::CollectionWriteInfoT>& collInfo);
-
-/// Helper struct to get the negative offsets from the end of the branches
-/// vector for the different types of generic parameters.
-template <typename T>
-struct TypeToBranchIndexOffset;
-
-template <>
-struct TypeToBranchIndexOffset<int> {
-  constexpr static int keys = 8;
-  constexpr static int values = 7;
-};
-
-template <>
-struct TypeToBranchIndexOffset<float> {
-  constexpr static int keys = 6;
-  constexpr static int values = 5;
-};
-
-template <>
-struct TypeToBranchIndexOffset<double> {
-  constexpr static int keys = 4;
-  constexpr static int values = 3;
-};
-
-template <>
-struct TypeToBranchIndexOffset<std::string> {
-  constexpr static int keys = 2;
-  constexpr static int values = 1;
-};
-
-template <typename T>
-void ROOTReader::readParams(ROOTReader::CategoryInfo& catInfo, podio::GenericParameters& params, bool reloadBranches,
-                            unsigned int localEntry) {
-  const auto nBranches = catInfo.branches.size();
-  if (reloadBranches) {
-    auto& keyBranch = catInfo.branches[nBranches - TypeToBranchIndexOffset<T>::keys].data;
-    keyBranch = root_utils::getBranch(catInfo.chain.get(), root_utils::getGPKeyName<T>());
-    auto& valueBranch = catInfo.branches[nBranches - TypeToBranchIndexOffset<T>::values].data;
-    valueBranch = root_utils::getBranch(catInfo.chain.get(), root_utils::getGPValueName<T>());
-  }
-
-  auto keyBranch = catInfo.branches[nBranches - TypeToBranchIndexOffset<T>::keys].data;
-  auto valueBranch = catInfo.branches[nBranches - TypeToBranchIndexOffset<T>::values].data;
-
-  root_utils::ParamStorage<T> storage;
-  keyBranch->SetAddress(storage.keysPtr());
-  keyBranch->GetEntry(localEntry);
-  valueBranch->SetAddress(storage.valuesPtr());
-  valueBranch->GetEntry(localEntry);
-
-  for (size_t i = 0; i < storage.keys.size(); ++i) {
-    params.getMap<T>().emplace(std::move(storage.keys[i]), std::move(storage.values[i]));
-  }
-}
+                                   const std::vector<root_utils::CollectionInfoT>& collInfo);
 
 GenericParameters ROOTReader::readEntryParameters(ROOTReader::CategoryInfo& catInfo, bool reloadBranches,
                                                   unsigned int localEntry) {
-  GenericParameters params;
-
-  if (m_fileVersion < podio::version::Version{0, 99, 99}) {
-    // Parameter branch is always the last one
-    auto& paramBranches = catInfo.branches.back();
-
-    // Make sure to have a valid branch pointer after switching trees in the chain
-    // as well as on the first event
-    if (reloadBranches) {
-      paramBranches.data = root_utils::getBranch(catInfo.chain.get(), root_utils::paramBranchName);
-    }
-    auto* branch = paramBranches.data;
+  // Parameter branch is always the last one
+  auto& paramBranches = catInfo.branches.back();
 
-    auto* emd = &params;
-    branch->SetAddress(&emd);
-    branch->GetEntry(localEntry);
-  } else {
-    readParams<int>(catInfo, params, reloadBranches, localEntry);
-    readParams<float>(catInfo, params, reloadBranches, localEntry);
-    readParams<double>(catInfo, params, reloadBranches, localEntry);
-    readParams<std::string>(catInfo, params, reloadBranches, localEntry);
+  // Make sure to have a valid branch pointer after switching trees in the chain
+  // as well as on the first event
+  if (reloadBranches) {
+    paramBranches.data = root_utils::getBranch(catInfo.chain.get(), root_utils::paramBranchName);
   }
+  auto* branch = paramBranches.data;
 
+  GenericParameters params;
+  auto* emd = &params;
+  branch->SetAddress(&emd);
+  branch->GetEntry(localEntry);
   return params;
 }
 
@@ -199,7 +137,7 @@ void ROOTReader::initCategory(CategoryInfo& catInfo, const std::string& category
 
   auto* collInfoBranch = root_utils::getBranch(m_metaChain.get(), root_utils::collInfoName(category));
 
-  auto collInfo = new std::vector<root_utils::CollectionWriteInfoT>();
+  auto collInfo = new std::vector<root_utils::CollectionInfoT>();
   if (m_fileVersion < podio::version::Version{0, 16, 4}) {
     auto oldCollInfo = new std::vector<root_utils::CollectionInfoWithoutSchemaT>();
     collInfoBranch->SetAddress(&oldCollInfo);
@@ -224,25 +162,13 @@ void ROOTReader::initCategory(CategoryInfo& catInfo, const std::string& category
     std::tie(catInfo.branches, catInfo.storedClasses) =
         createCollectionBranches(catInfo.chain.get(), *catInfo.table, *collInfo);
   }
+
   delete collInfo;
 
   // Finally set up the branches for the parameters
-  if (m_fileVersion < podio::version::Version{0, 99, 99}) {
-    root_utils::CollectionBranches paramBranches{};
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::paramBranchName));
-  } else {
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::intKeyName));
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::intValueName));
-
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::floatKeyName));
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::floatValueName));
-
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::doubleKeyName));
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::doubleValueName));
-
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::stringKeyName));
-    catInfo.branches.emplace_back(root_utils::getBranch(catInfo.chain.get(), root_utils::stringValueName));
-  }
+  root_utils::CollectionBranches paramBranches{};
+  paramBranches.data = root_utils::getBranch(catInfo.chain.get(), root_utils::paramBranchName);
+  catInfo.branches.push_back(paramBranches);
 }
 
 std::vector<std::string> getAvailableCategories(TChain* metaChain) {
@@ -327,7 +253,7 @@ std::vector<std::string_view> ROOTReader::getAvailableCategories() const {
 
 std::tuple<std::vector<root_utils::CollectionBranches>, std::vector<std::pair<std::string, detail::CollectionInfo>>>
 createCollectionBranchesIndexBased(TChain* chain, const podio::CollectionIDTable& idTable,
-                                   const std::vector<root_utils::CollectionWriteInfoT>& collInfo) {
+                                   const std::vector<root_utils::CollectionInfoT>& collInfo) {
 
   size_t collectionIndex{0};
   std::vector<root_utils::CollectionBranches> collBranches;
@@ -374,12 +300,12 @@ createCollectionBranchesIndexBased(TChain* chain, const podio::CollectionIDTable
     collBranches.emplace_back(std::move(branches));
   }
 
-  return {std::move(collBranches), storedClasses};
+  return {collBranches, storedClasses};
 }
 
 std::tuple<std::vector<root_utils::CollectionBranches>, std::vector<std::pair<std::string, detail::CollectionInfo>>>
 createCollectionBranches(TChain* chain, const podio::CollectionIDTable& idTable,
-                         const std::vector<root_utils::CollectionWriteInfoT>& collInfo) {
+                         const std::vector<root_utils::CollectionInfoT>& collInfo) {
 
   size_t collectionIndex{0};
   std::vector<root_utils::CollectionBranches> collBranches;
@@ -420,7 +346,7 @@ createCollectionBranches(TChain* chain, const podio::CollectionIDTable& idTable,
     collBranches.emplace_back(std::move(branches));
   }
 
-  return {std::move(collBranches), storedClasses};
+  return {collBranches, storedClasses};
 }
 
 } // namespace podio
diff --git a/src/ROOTWriter.cc b/src/ROOTWriter.cc
index df8e810fd..b38bc145b 100644
--- a/src/ROOTWriter.cc
+++ b/src/ROOTWriter.cc
@@ -8,7 +8,6 @@
 #include "rootUtils.h"
 
 #include "TTree.h"
-#include <tuple>
 
 namespace podio {
 
@@ -38,7 +37,7 @@ void ROOTWriter::writeFrame(const podio::Frame& frame, const std::string& catego
     catInfo.tree->SetDirectory(m_file.get());
   }
 
-  std::vector<root_utils::StoreCollection> collections;
+  std::vector<StoreCollection> collections;
   collections.reserve(catInfo.collsToWrite.size());
   for (const auto& name : catInfo.collsToWrite) {
     auto* coll = frame.getCollectionForWrite(name);
@@ -62,8 +61,7 @@ void ROOTWriter::writeFrame(const podio::Frame& frame, const std::string& catego
       throw std::runtime_error("Trying to write category '" + category + "' with inconsistent collection content. " +
                                root_utils::getInconsistentCollsMsg(catInfo.collsToWrite, collsToWrite));
     }
-    fillParams(catInfo, frame.getParameters());
-    resetBranches(catInfo, collections);
+    resetBranches(catInfo.branches, collections, &const_cast<podio::GenericParameters&>(frame.getParameters()));
   }
 
   catInfo.tree->Fill();
@@ -78,10 +76,9 @@ ROOTWriter::CategoryInfo& ROOTWriter::getCategoryInfo(const std::string& categor
   return it->second;
 }
 
-void ROOTWriter::initBranches(CategoryInfo& catInfo, const std::vector<root_utils::StoreCollection>& collections,
+void ROOTWriter::initBranches(CategoryInfo& catInfo, const std::vector<StoreCollection>& collections,
                               /*const*/ podio::GenericParameters& parameters) {
-  catInfo.branches.reserve(collections.size() +
-                           std::tuple_size_v<podio::SupportedGenericDataTypes> * 2); // collections + parameters
+  catInfo.branches.reserve(collections.size() + 1); // collections + parameters
 
   // First collections
   for (auto& [name, coll] : collections) {
@@ -120,45 +117,28 @@ void ROOTWriter::initBranches(CategoryInfo& catInfo, const std::vector<root_util
       }
     }
 
-    catInfo.branches.emplace_back(std::move(branches));
-    catInfo.collInfo.emplace_back(catInfo.idTable.collectionID(name).value(), std::string(coll->getTypeName()),
+    catInfo.branches.push_back(branches);
+    catInfo.collInfo.emplace_back(catInfo.idTable.collectionID(name).value(), coll->getTypeName(),
                                   coll->isSubsetCollection(), coll->getSchemaVersion());
   }
 
-  fillParams(catInfo, parameters);
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::intKeyName, &catInfo.intParams.keys));
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::intValueName, &catInfo.intParams.values));
-
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::floatKeyName, &catInfo.floatParams.keys));
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::floatValueName, &catInfo.floatParams.values));
-
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::doubleKeyName, &catInfo.doubleParams.keys));
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::doubleValueName, &catInfo.doubleParams.values));
-
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::stringKeyName, &catInfo.stringParams.keys));
-  catInfo.branches.emplace_back(catInfo.tree->Branch(root_utils::stringValueName, &catInfo.stringParams.values));
+  // Also make branches for the parameters
+  root_utils::CollectionBranches branches;
+  branches.data = catInfo.tree->Branch(root_utils::paramBranchName, &parameters);
+  catInfo.branches.push_back(branches);
 }
 
-void ROOTWriter::resetBranches(CategoryInfo& categoryInfo,
-                               const std::vector<root_utils::StoreCollection>& collections) {
+void ROOTWriter::resetBranches(std::vector<root_utils::CollectionBranches>& branches,
+                               const std::vector<ROOTWriter::StoreCollection>& collections,
+                               /*const*/ podio::GenericParameters* parameters) {
   size_t iColl = 0;
-  for (auto& [_, coll] : collections) {
-    const auto& collBranches = categoryInfo.branches[iColl];
-    root_utils::setCollectionAddresses(coll->getBuffers(), collBranches);
+  for (auto& coll : collections) {
+    const auto& collBranches = branches[iColl];
+    root_utils::setCollectionAddresses(coll.second->getBuffers(), collBranches);
     iColl++;
   }
 
-  categoryInfo.branches[iColl].data->SetAddress(categoryInfo.intParams.keysPtr());
-  categoryInfo.branches[iColl + 1].data->SetAddress(categoryInfo.intParams.valuesPtr());
-
-  categoryInfo.branches[iColl + 2].data->SetAddress(categoryInfo.floatParams.keysPtr());
-  categoryInfo.branches[iColl + 3].data->SetAddress(categoryInfo.floatParams.valuesPtr());
-
-  categoryInfo.branches[iColl + 4].data->SetAddress(categoryInfo.doubleParams.keysPtr());
-  categoryInfo.branches[iColl + 5].data->SetAddress(categoryInfo.doubleParams.valuesPtr());
-
-  categoryInfo.branches[iColl + 6].data->SetAddress(categoryInfo.stringParams.keysPtr());
-  categoryInfo.branches[iColl + 7].data->SetAddress(categoryInfo.stringParams.valuesPtr());
+  branches.back().data->SetAddress(&parameters);
 }
 
 void ROOTWriter::finish() {
@@ -195,11 +175,4 @@ ROOTWriter::checkConsistency(const std::vector<std::string>& collsToWrite, const
   return {std::vector<std::string>{}, collsToWrite};
 }
 
-void ROOTWriter::fillParams(CategoryInfo& catInfo, const GenericParameters& params) {
-  catInfo.intParams = {params.getKeys<int>(), params.getValues<int>()};
-  catInfo.floatParams = {params.getKeys<float>(), params.getValues<float>()};
-  catInfo.doubleParams = {params.getKeys<double>(), params.getValues<double>()};
-  catInfo.stringParams = {params.getKeys<std::string>(), params.getValues<std::string>()};
-}
-
 } // namespace podio
diff --git a/src/rootUtils.h b/src/rootUtils.h
index c9e7c1238..5fb7aa7d3 100644
--- a/src/rootUtils.h
+++ b/src/rootUtils.h
@@ -1,10 +1,14 @@
 #ifndef PODIO_ROOT_UTILS_H // NOLINT(llvm-header-guard): internal headers confuse clang-tidy
 #define PODIO_ROOT_UTILS_H // NOLINT(llvm-header-guard): internal headers confuse clang-tidy
 
+#include "podio/CollectionBase.h"
+#include "podio/CollectionBranches.h"
+#include "podio/CollectionBuffers.h"
 #include "podio/CollectionIDTable.h"
-#include "podio/utilities/RootHelpers.h"
 
 #include "TBranch.h"
+#include "TChain.h"
+#include "TClass.h"
 #include "TTree.h"
 
 #include <algorithm>
@@ -199,6 +203,13 @@ inline void setCollectionAddresses(const BufferT& collBuffers, const CollectionB
   }
 }
 
+// A collection of additional information that describes the collection: the
+// collectionID, the collection (data) type, whether it is a subset
+// collection, and its schema version
+using CollectionInfoT = std::tuple<uint32_t, std::string, bool, unsigned int>;
+// for backwards compatibility
+using CollectionInfoWithoutSchemaT = std::tuple<int, std::string, bool>;
+
 inline void readBranchesData(const CollectionBranches& branches, Long64_t entry) {
   // Read all data
   if (branches.data) {
@@ -222,7 +233,7 @@ inline void readBranchesData(const CollectionBranches& branches, Long64_t entry)
  * collections
  */
 inline auto reconstructCollectionInfo(TTree* eventTree, podio::CollectionIDTable const& idTable) {
-  std::vector<CollectionWriteInfoT> collInfo;
+  std::vector<CollectionInfoT> collInfo;
 
   for (size_t iColl = 0; iColl < idTable.names().size(); ++iColl) {
     const auto collID = idTable.ids()[iColl];
diff --git a/src/selection.xml b/src/selection.xml
index 82acdc661..03686376f 100644
--- a/src/selection.xml
+++ b/src/selection.xml
@@ -10,7 +10,6 @@
     <class name="podio::GenericParameters::MapType<float>"/>
     <class name="podio::GenericParameters::MapType<double>"/>
     <class name="podio::GenericParameters::MapType<std::string>"/>
-
     <class name="std::vector<std::tuple<int, std::string, bool, unsigned int>>"/>
     <class name="std::vector<std::tuple<int, std::string, bool, unsigned>>"/>
     <class name="std::vector<std::tuple<int, std::string, bool>>"/>
@@ -18,12 +17,6 @@
     <class name="std::vector<std::tuple<uint32_t, std::string, bool, unsigned int>>"/>
     <class name="std::vector<std::tuple<uint32_t, std::string, bool, unsigned>>"/>
     <class name="std::vector<std::tuple<uint32_t, std::string, bool>>"/>
-
-    <class name="std::vector<std::vector<std::string>>"/>
-    <class name="std::vector<std::vector<int>>"/>
-    <class name="std::vector<std::vector<float>>"/>
-    <class name="std::vector<std::vector<double>>"/>
-
     <class name="podio::CollectionBase"/>
     <class name="podio::CollectionIDTable">
         <field name="m_mutex" transient="true"/>
@@ -31,7 +24,6 @@
     <class name="podio::version::Version"/>
     <class name="podio::ObjectID"/>
     <class name="vector<podio::ObjectID>"/>
-
     <class name="podio::UserDataCollection<float>"/>
     <class name="podio::UserDataCollection<double>"/>
     <class name="podio::UserDataCollection<int8_t>"/>
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index aa417badd..729248b91 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -59,7 +59,6 @@ set(root_legacy_test_versions
   v00-16-02
   v00-16-05
   v00-16-06
-  v00-99
 )
 
 add_subdirectory(root_io)
@@ -67,7 +66,6 @@ if (ENABLE_SIO)
   set(sio_legacy_test_versions
     v00-16-05
     v00-16-06
-    v00-99
   )
 
   add_subdirectory(sio_io)
diff --git a/tests/input_files/v00-99-example_frame.root.md5 b/tests/input_files/v00-99-example_frame.root.md5
deleted file mode 100644
index 5b52257e6..000000000
--- a/tests/input_files/v00-99-example_frame.root.md5
+++ /dev/null
@@ -1 +0,0 @@
-dbd91affe295c85c1838c40fb9da5013
diff --git a/tests/input_files/v00-99-example_frame.sio.md5 b/tests/input_files/v00-99-example_frame.sio.md5
deleted file mode 100644
index c57b2a6bb..000000000
--- a/tests/input_files/v00-99-example_frame.sio.md5
+++ /dev/null
@@ -1 +0,0 @@
-ad1945557d6b5e02620294c7edac3f99
diff --git a/tests/root_io/CMakeLists.txt b/tests/root_io/CMakeLists.txt
index fd9c5c0e9..6a4069a48 100644
--- a/tests/root_io/CMakeLists.txt
+++ b/tests/root_io/CMakeLists.txt
@@ -45,9 +45,7 @@ target_link_libraries(read_frame_legacy_root PRIVATE "${root_libs}")
 
 foreach(version IN LISTS root_legacy_test_versions)
   ADD_PODIO_LEGACY_TEST(${version} read_frame_root ${version}-example_frame.root)
-  if (version MATCHES "^v00-16")
-    ADD_PODIO_LEGACY_TEST(${version} read_frame_legacy_root ${version}-example.root)
-  endif()
+  ADD_PODIO_LEGACY_TEST(${version} read_frame_legacy_root ${version}-example.root)
 endforeach()
 
 #--- Write via python and the ROOT backend and see if we can read it back in in
diff --git a/tests/sio_io/CMakeLists.txt b/tests/sio_io/CMakeLists.txt
index 7f53917fe..7102c36c7 100644
--- a/tests/sio_io/CMakeLists.txt
+++ b/tests/sio_io/CMakeLists.txt
@@ -33,7 +33,5 @@ target_link_libraries(read_frame_legacy_sio PRIVATE "${sio_libs}" TestDataModel)
 
 foreach(version IN LISTS sio_legacy_test_versions)
   ADD_PODIO_LEGACY_TEST(${version} read_frame_sio ${version}-example_frame.sio)
-  if (version MATCHES "^v00-16")
-    ADD_PODIO_LEGACY_TEST(${version} read_frame_legacy_sio ${version}-example.sio)
-  endif()
+  ADD_PODIO_LEGACY_TEST(${version} read_frame_legacy_sio ${version}-example.sio)
 endforeach()