diff --git a/form/form/form.cpp b/form/form/form.cpp
index 8689685d..70fa7853 100644
--- a/form/form/form.cpp
+++ b/form/form/form.cpp
@@ -2,12 +2,14 @@
 
 #include "form.hpp"
 
+#include <stdexcept>
+#include <typeinfo>
+
 namespace form::experimental {
 
-  form_interface::form_interface(std::shared_ptr<product_type_names> tm,
-                                 config::output_item_config const& output_config,
+  form_interface::form_interface(config::output_item_config const& output_config,
                                  config::tech_setting_config const& tech_config) :
-    m_pers(nullptr), m_type_map(tm)
+    m_pers(nullptr)
   {
     for (auto const& item : output_config.getItems()) {
       m_product_to_config.emplace(item.product_name,
@@ -30,12 +32,10 @@ namespace form::experimental {
       throw std::runtime_error("No configuration found for product: " + pb.label);
     }
 
-    std::string const type = m_type_map->names[pb.type];
-
-    std::map<std::string, std::string> products = {{pb.label, type}};
+    std::map<std::string, std::type_info const*> products = {{pb.label, pb.type}};
     m_pers->createContainers(creator, products);
 
-    m_pers->registerWrite(creator, pb.label, pb.data, type);
+    m_pers->registerWrite(creator, pb.label, pb.data, *pb.type);
 
     m_pers->commitOutput(creator, segment_id);
   }
@@ -54,18 +54,16 @@ namespace form::experimental {
     }
 
     // FIXME: Really only needed on first call
-    std::map<std::string, std::string> product_types;
+    std::map<std::string, std::type_info const*> product_types;
     for (auto const& pb : products) {
-      std::string const& type = m_type_map->names[pb.type];
-      product_types.insert(std::make_pair(pb.label, type));
+      product_types.insert(std::make_pair(pb.label, pb.type));
     }
 
     m_pers->createContainers(creator, product_types);
 
     for (auto const& pb : products) {
-      std::string const& type = m_type_map->names[pb.type];
       // FIXME: We could consider checking id to be identical for all product bases here
-      m_pers->registerWrite(creator, pb.label, pb.data, type);
+      m_pers->registerWrite(creator, pb.label, pb.data, *pb.type);
     }
 
     m_pers->commitOutput(creator, segment_id);
@@ -81,8 +79,6 @@ namespace form::experimental {
       throw std::runtime_error("No configuration found for product: " + pb.label);
     }
 
-    std::string type = m_type_map->names[pb.type];
-
-    m_pers->read(creator, pb.label, segment_id, &pb.data, type);
+    m_pers->read(creator, pb.label, segment_id, &pb.data, *pb.type);
   }
 }
diff --git a/form/form/form.hpp b/form/form/form.hpp
index 52b8e076..2983a9ca 100644
--- a/form/form/form.hpp
+++ b/form/form/form.hpp
@@ -9,26 +9,20 @@
 #include <map>
 #include <memory>
 #include <string>
-#include <typeindex>
-#include <unordered_map>
+#include <typeinfo>
 #include <vector>
 
 namespace form::experimental {
 
-  struct product_type_names {
-    std::unordered_map<std::type_index, std::string> names;
-  };
-
   struct product_with_name {
     std::string label;
     void const* data;
-    std::type_index type;
+    std::type_info const* type;
   };
 
   class form_interface {
   public:
-    form_interface(std::shared_ptr<product_type_names> tm,
-                   config::output_item_config const& output_config,
+    form_interface(config::output_item_config const& output_config,
                    config::tech_setting_config const& tech_config);
     ~form_interface() = default;
 
@@ -46,7 +40,6 @@ namespace form::experimental {
 
   private:
     std::unique_ptr<form::detail::experimental::IPersistence> m_pers;
-    std::shared_ptr<product_type_names> m_type_map;
     std::map<std::string, form::experimental::config::PersistenceItem> m_product_to_config;
   };
 }
diff --git a/form/form_module.cpp b/form/form_module.cpp
index 3a902637..3578c323 100644
--- a/form/form_module.cpp
+++ b/form/form_module.cpp
@@ -14,11 +14,10 @@ namespace {
 
   class FormOutputModule {
   public:
-    FormOutputModule(std::shared_ptr<form::experimental::product_type_names> type_map,
-                     std::string output_file,
+    FormOutputModule(std::string output_file,
                      int technology,
                      std::vector<std::string> const& products_to_save) :
-      m_type_map(type_map), m_output_file(std::move(output_file)), m_technology(technology)
+      m_output_file(std::move(output_file)), m_technology(technology)
     {
       std::cout << "FormOutputModule initialized\n";
       std::cout << "  Output file: " << m_output_file << "\n";
@@ -39,8 +38,7 @@ namespace {
       }
 
       // Initialize FORM interface
-      m_form_interface =
-        std::make_unique<form::experimental::form_interface>(type_map, output_cfg, tech_cfg);
+      m_form_interface = std::make_unique<form::experimental::form_interface>(output_cfg, tech_cfg);
     }
 
     // This method is called by Phlex - signature must be: void(product_store const&)
@@ -82,7 +80,7 @@ namespace {
         // Create FORM product with metadata
         products.emplace_back(product_name,           // label, from map key
                               product_ptr->address(), // data,  from phlex product_base
-                              product_ptr->type()     // type,  from phlex product_base
+                              &product_ptr->type()    // type, from phlex product_base
         );
       }
 
@@ -96,7 +94,6 @@ namespace {
     }
 
   private:
-    std::shared_ptr<form::experimental::product_type_names> m_type_map;
     std::string m_output_file;
     int m_technology;
     std::unique_ptr<form::experimental::form_interface> m_form_interface;
@@ -108,19 +105,6 @@ PHLEX_REGISTER_ALGORITHMS(m, config)
 {
   std::cout << "Registering FORM output module...\n";
 
-  // Create type map
-  auto type_map = std::make_shared<form::experimental::product_type_names>();
-
-  // Register some fundamental type for simple products
-  type_map->names[std::type_index(typeid(int))] = "int";
-  type_map->names[std::type_index(typeid(long))] = "long";
-  type_map->names[std::type_index(typeid(float))] = "float";
-  type_map->names[std::type_index(typeid(double))] = "double";
-  type_map->names[std::type_index(typeid(std::vector<int>))] = "std::vector<int>";
-  type_map->names[std::type_index(typeid(std::vector<long>))] = "std::vector<long>";
-  type_map->names[std::type_index(typeid(std::vector<float>))] = "std::vector<float>";
-  type_map->names[std::type_index(typeid(std::vector<double>))] = "std::vector<double>";
-
   // Extract configuration from Phlex config
   std::string output_file = config.get<std::string>("output_file", "output.root");
   std::string tech_string = config.get<std::string>("technology", "ROOT_TTREE");
@@ -146,7 +130,7 @@ PHLEX_REGISTER_ALGORITHMS(m, config)
 
   // Phlex needs an OBJECT
   // Create the FORM output module
-  auto form_output = m.make<FormOutputModule>(type_map, output_file, technology, products_to_save);
+  auto form_output = m.make<FormOutputModule>(output_file, technology, products_to_save);
 
   // Phlex needs a MEMBER FUNCTION to call
   // Register the callback that Phlex will invoke
diff --git a/form/persistence/ipersistence.hpp b/form/persistence/ipersistence.hpp
index 36cd535b..4d0b7386 100644
--- a/form/persistence/ipersistence.hpp
+++ b/form/persistence/ipersistence.hpp
@@ -6,6 +6,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <typeinfo>
 
 namespace form::experimental::config {
   class output_item_config;
@@ -26,18 +27,18 @@ namespace form::detail::experimental {
       form::experimental::config::output_item_config const& outputItems) = 0;
 
     virtual void createContainers(std::string const& creator,
-                                  std::map<std::string, std::string> const& products) = 0;
+                                  std::map<std::string, std::type_info const*> const& products) = 0;
     virtual void registerWrite(std::string const& creator,
                                std::string const& label,
                                void const* data,
-                               std::string const& type) = 0;
+                               std::type_info const& type) = 0;
     virtual void commitOutput(std::string const& creator, std::string const& id) = 0;
 
     virtual void read(std::string const& creator,
                       std::string const& label,
                       std::string const& id,
                       void const** data,
-                      std::string& type) = 0;
+                      std::type_info const& type) = 0;
   };
 
   std::unique_ptr<IPersistence> createPersistence();
diff --git a/form/persistence/persistence.cpp b/form/persistence/persistence.cpp
index 0c1214e2..9c52798a 100644
--- a/form/persistence/persistence.cpp
+++ b/form/persistence/persistence.cpp
@@ -4,6 +4,9 @@
 
 #include <algorithm>
 #include <cstring>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
 #include <utility>
 
 using namespace form::detail::experimental;
@@ -31,13 +34,13 @@ void Persistence::configureOutputItems(
 }
 
 void Persistence::createContainers(std::string const& creator,
-                                   std::map<std::string, std::string> const& products)
+                                   std::map<std::string, std::type_info const*> const& products)
 {
-  std::map<std::unique_ptr<Placement>, std::string> containers;
+  std::map<std::unique_ptr<Placement>, std::type_info const*> containers;
   for (auto const& [label, type] : products) {
     containers.insert(std::make_pair(getPlacement(creator, label), type));
   }
-  containers.insert(std::make_pair(getPlacement(creator, "index"), "std::string"));
+  containers.insert(std::make_pair(getPlacement(creator, "index"), &typeid(std::string)));
   m_store->createContainers(containers, m_tech_settings);
   return;
 }
@@ -45,7 +48,7 @@ void Persistence::createContainers(std::string const& creator,
 void Persistence::registerWrite(std::string const& creator,
                                 std::string const& label,
                                 void const* data,
-                                std::string const& type)
+                                std::type_info const& type)
 {
   std::unique_ptr<Placement> plcmnt = getPlacement(creator, label);
   m_store->fillContainer(*plcmnt, data, type);
@@ -55,7 +58,7 @@ void Persistence::registerWrite(std::string const& creator,
 void Persistence::commitOutput(std::string const& creator, std::string const& id)
 {
   std::unique_ptr<Placement> plcmnt = getPlacement(creator, "index");
-  m_store->fillContainer(*plcmnt, &id, "std::string");
+  m_store->fillContainer(*plcmnt, &id, typeid(std::string));
   m_store->commitContainers(*plcmnt);
   return;
 }
@@ -64,7 +67,7 @@ void Persistence::read(std::string const& creator,
                        std::string const& label,
                        std::string const& id,
                        void const** data,
-                       std::string& type)
+                       std::type_info const& type)
 {
   std::unique_ptr<Token> token = getToken(creator, label, id);
   m_store->readContainer(*token, data, type, m_tech_settings);
diff --git a/form/persistence/persistence.hpp b/form/persistence/persistence.hpp
index 36af8ac5..d7ff4598 100644
--- a/form/persistence/persistence.hpp
+++ b/form/persistence/persistence.hpp
@@ -32,18 +32,18 @@ namespace form::detail::experimental {
       form::experimental::config::output_item_config const& output_items) override;
 
     void createContainers(std::string const& creator,
-                          std::map<std::string, std::string> const& products) override;
+                          std::map<std::string, std::type_info const*> const& products) override;
     void registerWrite(std::string const& creator,
                        std::string const& label,
                        void const* data,
-                       std::string const& type) override;
+                       std::type_info const& type) override;
     void commitOutput(std::string const& creator, std::string const& id) override;
 
     void read(std::string const& creator,
               std::string const& label,
               std::string const& id,
               void const** data,
-              std::string& type) override;
+              std::type_info const& type) override;
 
   private:
     std::unique_ptr<Placement> getPlacement(std::string const& creator, std::string const& label);
diff --git a/form/root_storage/root_tbranch_container.cpp b/form/root_storage/root_tbranch_container.cpp
index e8b7e566..9c0c6f69 100644
--- a/form/root_storage/root_tbranch_container.cpp
+++ b/form/root_storage/root_tbranch_container.cpp
@@ -5,6 +5,7 @@
 #include "root_ttree_container.hpp"
 
 #include "TBranch.h"
+#include "TClassEdit.h"
 #include "TFile.h"
 #include "TLeaf.h"
 #include "TTree.h"
@@ -12,6 +13,20 @@
 #include <unordered_map>
 
 namespace {
+  // Return the demangled type name
+  std::string DemangleName(std::type_info const& type)
+  {
+    int errorCode;
+    // The TClassEdit version works on both linux and Windows.
+    char* demangledName = TClassEdit::DemangleTypeIdName(type, errorCode);
+    if (errorCode != 0) {
+      // NOTE: Instead of throwing, we could return the mangled name as a fallback.
+      throw std::runtime_error("Failed to demangle type name");
+    }
+    std::string result(demangledName);
+    std::free(demangledName);
+    return result;
+  }
   //Type name conversion based on https://root.cern.ch/doc/master/classTTree.html#ac1fa9466ce018d4aa739b357f981c615
   //An empty leaf list defaults to Float_t
   std::unordered_map<std::string, std::string> typeNameToLeafList = {{"int", "/I"},
@@ -63,16 +78,18 @@ void ROOT_TBranch_ContainerImp::setParent(std::shared_ptr<IStorage_Container> pa
   return;
 }
 
-void ROOT_TBranch_ContainerImp::setupWrite(std::string const& type)
+void ROOT_TBranch_ContainerImp::setupWrite(std::type_info const& type)
 {
   if (m_tree == nullptr) {
     throw std::runtime_error("ROOT_TBranch_ContainerImp::setupWrite no tree found");
   }
 
-  auto dictInfo = TDictionary::GetDictionary(type.c_str());
+  auto dictInfo = TDictionary::GetDictionary(type);
   if (m_branch == nullptr) {
     if (!dictInfo) {
-      throw std::runtime_error("ROOT_TBranch_ContainerImp::setupWrite unsupported type: " + type);
+      throw std::runtime_error(
+        std::string{"ROOT_TBranch_ContainerImp::setupWrite unsupported type: "} +
+        DemangleName(type));
     }
     if (dictInfo->Property() & EProperty::kIsFundamental) {
       m_branch = m_tree->Branch(col_name().c_str(),
@@ -117,7 +134,7 @@ void ROOT_TBranch_ContainerImp::commit()
   return;
 }
 
-bool ROOT_TBranch_ContainerImp::read(int id, void const** data, std::string& type)
+bool ROOT_TBranch_ContainerImp::read(int id, void const** data, std::type_info const& type)
 {
   if (m_tfile == nullptr) {
     throw std::runtime_error("ROOT_TBranch_ContainerImp::read no file attached");
@@ -138,23 +155,34 @@ bool ROOT_TBranch_ContainerImp::read(int id, void const** data, std::string& typ
     return false;
 
   void* branchBuffer = nullptr;
-  auto dictInfo = TClass::GetClass(type.c_str());
+  auto dictInfo = TDictionary::GetDictionary(type);
   int branchStatus = 0;
-  if (dictInfo) {
-    branchBuffer = dictInfo->New();
-    branchStatus = m_tree->SetBranchAddress(
-      col_name().c_str(), &branchBuffer, TClass::GetClass(type.c_str()), EDataType::kOther_t, true);
-  } else {
-    //Assume this is a fundamental type like int or double
-    auto fundInfo = static_cast<TDataType*>(TDictionary::GetDictionary(type.c_str()));
+  if (!dictInfo) {
+    throw std::runtime_error(std::string{"ROOT_TBranch_ContainerImp::read unsupported type: "} +
+                             DemangleName(type));
+  }
+
+  if (dictInfo->Property() & EProperty::kIsFundamental) {
+    auto fundInfo = static_cast<TDataType*>(dictInfo);
     branchBuffer = new char[fundInfo->Size()];
     branchStatus = m_tree->SetBranchAddress(
       col_name().c_str(), &branchBuffer, nullptr, EDataType(fundInfo->GetType()), true);
+  } else {
+    auto klass = TClass::GetClass(type);
+    if (!klass) {
+      throw std::runtime_error(std::string{"ROOT_TBranch_ContainerImp::read missing TClass"} +
+                               " (col_name='" + col_name() + "', type='" + DemangleName(type) +
+                               "')");
+    }
+    branchBuffer = klass->New();
+    branchStatus =
+      m_tree->SetBranchAddress(col_name().c_str(), &branchBuffer, klass, EDataType::kOther_t, true);
   }
 
   if (branchStatus < 0) {
     throw std::runtime_error(
-      "ROOT_TBranch_ContainerImp::read SetBranchAddress() failed with error code " +
+      std::string{"ROOT_TBranch_ContainerImp::read SetBranchAddress() failed"} + " (col_name='" +
+      col_name() + "', type='" + DemangleName(type) + "')" + " with error code " +
       std::to_string(branchStatus));
   }
 
diff --git a/form/root_storage/root_tbranch_container.hpp b/form/root_storage/root_tbranch_container.hpp
index 3d2785dd..1fd21ebd 100644
--- a/form/root_storage/root_tbranch_container.hpp
+++ b/form/root_storage/root_tbranch_container.hpp
@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <typeinfo>
 
 class TFile;
 class TTree;
@@ -24,10 +25,10 @@ namespace form::detail::experimental {
     void setFile(std::shared_ptr<IStorage_File> file) override;
     void setParent(std::shared_ptr<IStorage_Container> parent) override;
 
-    void setupWrite(std::string const& type = "") override;
+    void setupWrite(std::type_info const& type = typeid(void)) override;
     void fill(void const* data) override;
     void commit() override;
-    bool read(int id, void const** data, std::string& type) override;
+    bool read(int id, void const** data, std::type_info const& type) override;
 
   private:
     std::shared_ptr<TFile> m_tfile;
diff --git a/form/root_storage/root_ttree_container.cpp b/form/root_storage/root_ttree_container.cpp
index 1300f1ce..adc529ba 100644
--- a/form/root_storage/root_ttree_container.cpp
+++ b/form/root_storage/root_ttree_container.cpp
@@ -38,7 +38,7 @@ void ROOT_TTree_ContainerImp::setFile(std::shared_ptr<IStorage_File> file)
   return;
 }
 
-void ROOT_TTree_ContainerImp::setupWrite(std::string const& /* type*/)
+void ROOT_TTree_ContainerImp::setupWrite(std::type_info const& /*type*/)
 {
   if (m_tfile == nullptr) {
     throw std::runtime_error("ROOT_TTree_ContainerImp::setupWrite no file attached");
@@ -69,7 +69,9 @@ void ROOT_TTree_ContainerImp::commit()
   throw std::runtime_error("ROOT_TTree_ContainerImp::commit not implemented");
 }
 
-bool ROOT_TTree_ContainerImp::read(int /* id*/, void const** /* data*/, std::string& /* type*/)
+bool ROOT_TTree_ContainerImp::read(int /* id*/,
+                                   void const** /* data*/,
+                                   std::type_info const& /* type*/)
 {
   throw std::runtime_error("ROOT_TTree_ContainerImp::read not implemented");
 }
diff --git a/form/root_storage/root_ttree_container.hpp b/form/root_storage/root_ttree_container.hpp
index 5133ebe8..077558f6 100644
--- a/form/root_storage/root_ttree_container.hpp
+++ b/form/root_storage/root_ttree_container.hpp
@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <typeinfo>
 
 class TFile;
 class TTree;
@@ -22,10 +23,10 @@ namespace form::detail::experimental {
     ROOT_TTree_ContainerImp& operator=(ROOT_TTree_ContainerImp& other) = delete;
 
     void setFile(std::shared_ptr<IStorage_File> file) override;
-    void setupWrite(std::string const& type = "") override;
+    void setupWrite(std::type_info const& type = typeid(void)) override;
     void fill(void const* data) override;
     void commit() override;
-    bool read(int id, void const** data, std::string& type) override;
+    bool read(int id, void const** data, std::type_info const& type) override;
 
     TTree* getTTree();
 
diff --git a/form/storage/istorage.hpp b/form/storage/istorage.hpp
index 647c06df..f109b1f2 100644
--- a/form/storage/istorage.hpp
+++ b/form/storage/istorage.hpp
@@ -10,6 +10,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <typeinfo>
 #include <vector>
 
 namespace form::detail::experimental {
@@ -20,11 +21,11 @@ namespace form::detail::experimental {
     virtual ~IStorage() = default;
 
     virtual void createContainers(
-      std::map<std::unique_ptr<Placement>, std::string> const& containers,
+      std::map<std::unique_ptr<Placement>, std::type_info const*> const& containers,
       form::experimental::config::tech_setting_config const& settings) = 0;
     virtual void fillContainer(Placement const& plcmnt,
                                void const* data,
-                               std::string const& type) = 0;
+                               std::type_info const& type) = 0;
     virtual void commitContainers(Placement const& plcmnt) = 0;
 
     virtual int getIndex(Token const& token,
@@ -32,7 +33,7 @@ namespace form::detail::experimental {
                          form::experimental::config::tech_setting_config const& settings) = 0;
     virtual void readContainer(Token const& token,
                                void const** data,
-                               std::string& type,
+                               std::type_info const& type,
                                form::experimental::config::tech_setting_config const& settings) = 0;
   };
 
@@ -55,10 +56,10 @@ namespace form::detail::experimental {
     virtual std::string const& name() = 0;
 
     virtual void setFile(std::shared_ptr<IStorage_File> file) = 0;
-    virtual void setupWrite(std::string const& type = "") = 0;
+    virtual void setupWrite(std::type_info const& type = typeid(void)) = 0;
     virtual void fill(void const* data) = 0;
     virtual void commit() = 0;
-    virtual bool read(int id, void const** data, std::string& type) = 0;
+    virtual bool read(int id, void const** data, std::type_info const& type) = 0;
 
     virtual void setAttribute(std::string const& name, std::string const& value) = 0;
   };
diff --git a/form/storage/storage.cpp b/form/storage/storage.cpp
index b93b39ee..5d67ad73 100644
--- a/form/storage/storage.cpp
+++ b/form/storage/storage.cpp
@@ -7,6 +7,10 @@
 
 #include "util/factories.hpp"
 
+#include <memory>
+#include <stdexcept>
+#include <typeinfo>
+
 using namespace form::detail::experimental;
 
 // Factory function implementation
@@ -14,8 +18,9 @@ namespace form::detail::experimental {
   std::unique_ptr<IStorage> createStorage() { return std::unique_ptr<IStorage>(new Storage()); }
 }
 
-void Storage::createContainers(std::map<std::unique_ptr<Placement>, std::string> const& containers,
-                               form::experimental::config::tech_setting_config const& settings)
+void Storage::createContainers(
+  std::map<std::unique_ptr<Placement>, std::type_info const*> const& containers,
+  form::experimental::config::tech_setting_config const& settings)
 {
   for (auto const& [plcmnt, type] : containers) {
     // Use file+container as composite key
@@ -36,7 +41,8 @@ void Storage::createContainers(std::map<std::unique_ptr<Placement>, std::string>
       auto container = createContainer(plcmnt->technology(), plcmnt->containerName());
       m_containers.insert({key, container});
       // For associative container, create association layer
-      auto associative_container = dynamic_pointer_cast<Storage_Associative_Container>(container);
+      auto associative_container =
+        std::dynamic_pointer_cast<Storage_Associative_Container>(container);
       if (associative_container) {
         auto parent_key = std::make_pair(plcmnt->fileName(), associative_container->top_name());
         auto parent = m_containers.find(parent_key);
@@ -56,13 +62,19 @@ void Storage::createContainers(std::map<std::unique_ptr<Placement>, std::string>
            settings.getContainerTable(plcmnt->technology(), plcmnt->containerName()))
         container->setAttribute(key, value);
       container->setFile(file->second);
-      container->setupWrite(type);
+      if (!type) {
+        throw std::runtime_error("Storage::createContainers got nullptr type for container: " +
+                                 plcmnt->containerName());
+      }
+      container->setupWrite(*type);
     }
   }
   return;
 }
 
-void Storage::fillContainer(Placement const& plcmnt, void const* data, std::string const& /* type*/)
+void Storage::fillContainer(Placement const& plcmnt,
+                            void const* data,
+                            std::type_info const& /* type*/)
 {
   // Use file+container as composite key
   auto key = std::make_pair(plcmnt.fileName(), plcmnt.containerName());
@@ -107,9 +119,8 @@ int Storage::getIndex(Token const& token,
       cont->second->setFile(file->second);
     }
     void const* data;
-    std::string type = "std::string";
     int entry = 1;
-    while (cont->second->read(entry, &data, type)) {
+    while (cont->second->read(entry, &data, typeid(std::string))) {
       m_indexMaps[token.containerName()].insert(
         std::make_pair(*(static_cast<std::string const*>(data)), entry));
       delete static_cast<std::string const*>(
@@ -123,7 +134,7 @@ int Storage::getIndex(Token const& token,
 
 void Storage::readContainer(Token const& token,
                             void const** data,
-                            std::string& type,
+                            std::type_info const& type,
                             form::experimental::config::tech_setting_config const& settings)
 {
   auto key = std::make_pair(token.fileName(), token.containerName());
diff --git a/form/storage/storage.hpp b/form/storage/storage.hpp
index 730f7c7b..e0d1f9f1 100644
--- a/form/storage/storage.hpp
+++ b/form/storage/storage.hpp
@@ -30,9 +30,12 @@ namespace form::detail::experimental {
     ~Storage() = default;
 
     using table_t = form::experimental::config::tech_setting_config::table_t;
-    void createContainers(std::map<std::unique_ptr<Placement>, std::string> const& containers,
-                          form::experimental::config::tech_setting_config const& settings) override;
-    void fillContainer(Placement const& plcmnt, void const* data, std::string const& type) override;
+    void createContainers(
+      std::map<std::unique_ptr<Placement>, std::type_info const*> const& containers,
+      form::experimental::config::tech_setting_config const& settings) override;
+    void fillContainer(Placement const& plcmnt,
+                       void const* data,
+                       std::type_info const& type) override;
     void commitContainers(Placement const& plcmnt) override;
 
     int getIndex(Token const& token,
@@ -40,7 +43,7 @@ namespace form::detail::experimental {
                  form::experimental::config::tech_setting_config const& settings) override;
     void readContainer(Token const& token,
                        void const** data,
-                       std::string& type,
+                       std::type_info const& type,
                        form::experimental::config::tech_setting_config const& settings) override;
 
   private:
diff --git a/form/storage/storage_container.cpp b/form/storage/storage_container.cpp
index 30a988c3..e3c61416 100644
--- a/form/storage/storage_container.cpp
+++ b/form/storage/storage_container.cpp
@@ -3,6 +3,8 @@
 #include "storage_container.hpp"
 #include "storage_file.hpp"
 
+#include <stdexcept>
+
 using namespace form::detail::experimental;
 
 Storage_Container::Storage_Container(std::string const& name) : m_name(name), m_file(nullptr) {}
@@ -11,13 +13,13 @@ std::string const& Storage_Container::name() { return m_name; }
 
 void Storage_Container::setFile(std::shared_ptr<IStorage_File> file) { m_file = file; }
 
-void Storage_Container::setupWrite(std::string const& /* type*/) { return; }
+void Storage_Container::setupWrite(std::type_info const& /*type*/) { return; }
 
 void Storage_Container::fill(void const* /* data*/) { return; }
 
 void Storage_Container::commit() { return; }
 
-bool Storage_Container::read(int /* id*/, void const** /*data*/, std::string& /* type*/)
+bool Storage_Container::read(int /* id*/, void const** /*data*/, std::type_info const& /* type*/)
 {
   return false;
 }
diff --git a/form/storage/storage_container.hpp b/form/storage/storage_container.hpp
index 6b595048..5a2b24bd 100644
--- a/form/storage/storage_container.hpp
+++ b/form/storage/storage_container.hpp
@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <typeinfo>
 
 namespace form::detail::experimental {
 
@@ -19,10 +20,10 @@ namespace form::detail::experimental {
 
     void setFile(std::shared_ptr<IStorage_File> file) override;
 
-    void setupWrite(std::string const& type = "") override;
+    void setupWrite(std::type_info const& type = typeid(void)) override;
     void fill(void const* data) override;
     void commit() override;
-    bool read(int id, void const** data, std::string& type) override;
+    bool read(int id, void const** data, std::type_info const& type) override;
 
     void setAttribute(std::string const& name, std::string const& value) override;
 
diff --git a/phlex/model/products.hpp b/phlex/model/products.hpp
index 8c8b0120..6d330a5c 100644
--- a/phlex/model/products.hpp
+++ b/phlex/model/products.hpp
@@ -6,7 +6,7 @@
 #include <cassert>
 #include <memory>
 #include <string>
-#include <typeindex>
+#include <typeinfo>
 #include <unordered_map>
 #include <utility>
 
@@ -15,7 +15,7 @@ namespace phlex::experimental {
   struct product_base {
     virtual ~product_base() = default;
     virtual void const* address() const = 0;
-    virtual std::type_index type() const = 0;
+    virtual std::type_info const& type() const = 0;
   };
 
   template <typename T>
@@ -28,7 +28,7 @@ namespace phlex::experimental {
     explicit product(T&& prod) : obj{std::move(prod)} {}
 
     void const* address() const final { return &obj; }
-    virtual std::type_index type() const { return std::type_index{typeid(T)}; }
+    std::type_info const& type() const final { return typeid(T); }
     std::remove_cvref_t<T> obj;
   };
 
diff --git a/test/form/reader.cpp b/test/form/reader.cpp
index aa30ceb2..e27569ba 100644
--- a/test/form/reader.cpp
+++ b/test/form/reader.cpp
@@ -20,9 +20,6 @@ int main(int argc, char** argv)
 
   std::string const filename = (argc > 1) ? argv[1] : "toy.root";
 
-  std::shared_ptr<form::experimental::product_type_names> type_map =
-    form::experimental::createTypeMap();
-
   // TODO: Read configuration from config file instead of hardcoding
   form::experimental::config::output_item_config output_config;
   output_config.addItem("trackStart", filename, form::technology::ROOT_TTREE);
@@ -32,7 +29,7 @@ int main(int argc, char** argv)
 
   form::experimental::config::tech_setting_config tech_config;
 
-  form::experimental::form_interface form(type_map, output_config, tech_config);
+  form::experimental::form_interface form(output_config, tech_config);
 
   for (int nevent = 0; nevent < NUMBER_EVENT; nevent++) {
     std::cout << "PHLEX: Read Event No. " << nevent << std::endl;
@@ -50,8 +47,7 @@ int main(int argc, char** argv)
       std::string const creator = "Toy_Tracker";
 
       form::experimental::product_with_name pb = {
-        "trackStart", track_start_x, std::type_index{typeid(std::vector<float>)}};
-      type_map->names[std::type_index(typeid(std::vector<float>))] = "std::vector<float>";
+        "trackStart", track_start_x, &typeid(std::vector<float>)};
 
       form.read(creator, segment_id, pb);
       track_start_x =
@@ -60,8 +56,7 @@ int main(int argc, char** argv)
       std::vector<int> const* track_n_hits = nullptr;
 
       form::experimental::product_with_name pb_int = {
-        "trackNumberHits", track_n_hits, std::type_index{typeid(std::vector<int>)}};
-      type_map->names[std::type_index(typeid(std::vector<int>))] = "std::vector<int>";
+        "trackNumberHits", track_n_hits, &typeid(std::vector<int>)};
 
       form.read(creator, segment_id, pb_int);
       track_n_hits = static_cast<std::vector<int> const*>(pb_int.data);
@@ -69,8 +64,7 @@ int main(int argc, char** argv)
       std::vector<TrackStart> const* start_points = nullptr;
 
       form::experimental::product_with_name pb_points = {
-        "trackStartPoints", start_points, std::type_index{typeid(std::vector<TrackStart>)}};
-      type_map->names[std::type_index(typeid(std::vector<TrackStart>))] = "std::vector<TrackStart>";
+        "trackStartPoints", start_points, &typeid(std::vector<TrackStart>)};
 
       form.read(creator, segment_id, pb_points);
       start_points = static_cast<std::vector<TrackStart> const*>(pb_points.data);
@@ -102,8 +96,7 @@ int main(int argc, char** argv)
     std::string const creator = "Toy_Tracker_Event";
 
     form::experimental::product_with_name pb = {
-      "trackStartX", track_x, std::type_index{typeid(std::vector<float>)}};
-    type_map->names[std::type_index(typeid(std::vector<float>))] = "std::vector<float>";
+      "trackStartX", track_x, &typeid(std::vector<float>)};
 
     form.read(creator, event_id, pb);
     track_x = static_cast<std::vector<float> const*>(pb.data); //FIXME: Can this be done by FORM?
diff --git a/test/form/test_helpers.hpp b/test/form/test_helpers.hpp
index c17ba03e..7a831766 100644
--- a/test/form/test_helpers.hpp
+++ b/test/form/test_helpers.hpp
@@ -4,36 +4,4 @@
 #include "data_products/track_start.hpp"
 #include "form/form.hpp"
 
-#include <memory>
-#include <string>
-#include <typeindex>
-
-namespace form::experimental {
-
-  // Helper to register a single type
-  template <typename T>
-  void registerType(product_type_names& map, std::string const& name)
-  {
-    map.names[std::type_index(typeid(T))] = name;
-  }
-
-  // Register vector types automatically
-  template <typename T>
-  void registerVectorType(product_type_names& map, std::string const& base_name)
-  {
-    map.names[std::type_index(typeid(T))] = base_name;
-    map.names[std::type_index(typeid(std::vector<T>))] = "std::vector<" + base_name + ">";
-  }
-
-  inline std::shared_ptr<product_type_names> createTypeMap()
-  {
-    auto type_map = std::make_shared<product_type_names>();
-    registerVectorType<TrackStart>(*type_map, "TrackStart");
-
-    // Register all your data product types here
-    // Easy to add more in the future:
-    return type_map;
-  }
-}
-
 #endif
diff --git a/test/form/writer.cpp b/test/form/writer.cpp
index 954dbbd9..91a74fef 100644
--- a/test/form/writer.cpp
+++ b/test/form/writer.cpp
@@ -36,9 +36,6 @@ int main(int argc, char** argv)
 
   std::string const filename = (argc > 1) ? argv[1] : "toy.root";
 
-  std::shared_ptr<form::experimental::product_type_names> type_map =
-    form::experimental::createTypeMap();
-
   // TODO: Read configuration from config file instead of hardcoding
   form::experimental::config::output_item_config output_config;
   output_config.addItem("trackStart", filename, form::technology::ROOT_TTREE);
@@ -54,7 +51,7 @@ int main(int argc, char** argv)
   tech_config.container_settings[form::technology::ROOT_RNTUPLE]["Toy_Tracker/trackStartPoints"]
     .emplace_back("force_streamer_field", "true");
 
-  form::experimental::form_interface form(type_map, output_config, tech_config);
+  form::experimental::form_interface form(output_config, tech_config);
 
   ToyTracker tracker(4 * 1024);
 
@@ -80,8 +77,7 @@ int main(int argc, char** argv)
       std::string const creator = "Toy_Tracker";
 
       form::experimental::product_with_name pb = {
-        "trackStart", &track_start_x, std::type_index{typeid(std::vector<float>)}};
-      type_map->names[std::type_index(typeid(std::vector<float>))] = "std::vector<float>";
+        "trackStart", &track_start_x, &typeid(std::vector<float>)};
       products.push_back(pb);
 
       std::vector<int> track_n_hits;
@@ -94,8 +90,7 @@ int main(int argc, char** argv)
                 << ", check = " << check << std::endl;
 
       form::experimental::product_with_name pb_int = {
-        "trackNumberHits", &track_n_hits, std::type_index{typeid(std::vector<int>)}};
-      type_map->names[std::type_index(typeid(std::vector<int>))] = "std::vector<int>";
+        "trackNumberHits", &track_n_hits, &typeid(std::vector<int>)};
       products.push_back(pb_int);
 
       std::vector<TrackStart> start_points = tracker();
@@ -106,8 +101,7 @@ int main(int argc, char** argv)
                 << ", checkPoints = " << checkPoints << std::endl;
 
       form::experimental::product_with_name pb_points = {
-        "trackStartPoints", &start_points, std::type_index{typeid(std::vector<TrackStart>)}};
-      type_map->names[std::type_index(typeid(std::vector<TrackStart>))] = "std::vector<TrackStart>";
+        "trackStartPoints", &start_points, &typeid(std::vector<TrackStart>)};
       products.push_back(pb_points);
 
       form.write(creator, segment_id, products);
@@ -129,8 +123,7 @@ int main(int argc, char** argv)
     std::string const creator = "Toy_Tracker_Event";
 
     form::experimental::product_with_name pb = {
-      "trackStartX", &track_x, std::type_index{typeid(std::vector<float>)}};
-    type_map->names[std::type_index(typeid(std::vector<float>))] = "std::vector<float>";
+      "trackStartX", &track_x, &typeid(std::vector<float>)};
     std::cout << "PHLEX: Event = " << nevent << ": evt_id_text = " << evt_id_text
               << ", check = " << check << std::endl;