diff --git a/data_tamer_cpp/include/data_tamer/channel.hpp b/data_tamer_cpp/include/data_tamer/channel.hpp
index 9c5fa2f..6cee1a5 100644
--- a/data_tamer_cpp/include/data_tamer/channel.hpp
+++ b/data_tamer_cpp/include/data_tamer/channel.hpp
@@ -9,6 +9,7 @@
 
 namespace DataTamer
 {
+using SerializeMe::has_TypeDefinition;
 
 // Utility
 inline std::chrono::nanoseconds NsecSinceEpoch()
@@ -73,7 +74,7 @@ class LogChannel : public std::enable_shared_from_this<LogChannel>
    * @param value  pointer to the value
    * @return       the ID to be used to unregister or enable/disable this value.
    */
-  template <typename T>
+  template <typename T, bool = true>
   RegistrationID registerValue(const std::string& name, const T* value);
 
   /**
@@ -85,7 +86,8 @@ class LogChannel : public std::enable_shared_from_this<LogChannel>
    * @param value  pointer to the vectors of values.
    * @return       the ID to be used to unregister or enable/disable the values.
    */
-  template <template <class, class> class Container, class T, class... TArgs>
+  template <template <class, class> class Container, class T, class... TArgs,
+            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   RegistrationID registerValue(const std::string& name,
                                const Container<T, TArgs...>* value);
 
@@ -98,7 +100,8 @@ class LogChannel : public std::enable_shared_from_this<LogChannel>
    * @param value  pointer to the array of values.
    * @return       the ID to be used to unregister or enable/disable the values.
    */
-  template <typename T, size_t N>
+  template <typename T, size_t N,
+            std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
   RegistrationID registerValue(const std::string& name, const std::array<T, N>* value);
 
   /**
@@ -259,7 +262,7 @@ inline void LogChannel::updateTypeRegistry()
   }
 }
 
-template <typename T>
+template <typename T, bool>
 inline RegistrationID LogChannel::registerValue(const std::string& name,
                                                 const T* value_ptr)
 {
@@ -288,7 +291,8 @@ inline RegistrationID LogChannel::registerCustomValue(const std::string& name,
   return registerValueImpl(name, ValuePtr(value_ptr, serializer), serializer);
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline RegistrationID LogChannel::registerValue(const std::string& prefix,
                                                 const Container<T, TArgs...>* vect)
 {
@@ -304,7 +308,8 @@ inline RegistrationID LogChannel::registerValue(const std::string& prefix,
   }
 }
 
-template <typename T, size_t N>
+template <typename T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline RegistrationID LogChannel::registerValue(const std::string& prefix,
                                                 const std::array<T, N>* vect)
 {
diff --git a/data_tamer_cpp/include/data_tamer/contrib/SerializeMe.hpp b/data_tamer_cpp/include/data_tamer/contrib/SerializeMe.hpp
index c96ba7d..9b31e9a 100644
--- a/data_tamer_cpp/include/data_tamer/contrib/SerializeMe.hpp
+++ b/data_tamer_cpp/include/data_tamer/contrib/SerializeMe.hpp
@@ -68,46 +68,79 @@ using SpanBytes = Span<uint8_t>;
 using SpanBytesConst = Span<uint8_t const>;
 using StringSize = uint16_t;
 
-//------------- Forward declarations of BufferSize ------------------
+// Check if a Function like this is implemented:
+//
+// template <typename Func> std::string_view TypeDefinition(T&, Func&);
+
+template <typename T, class = void>
+struct has_TypeDefinition : std::false_type
+{
+};
+
+const auto EmptyFuncion = [](const char*, void*) {};
+using EmptyFunc = decltype(EmptyFuncion);
+
+template <typename T1, typename T2>
+using enable_if_same_t = std::enable_if_t<std::is_same_v<T1, T2>>;
 
 template <typename T>
+struct has_TypeDefinition<
+    T, enable_if_same_t<std::string_view,
+                        decltype(TypeDefinition(std::declval<T&>(),
+                                                std::declval<EmptyFunc&>()))>>
+  : std::true_type
+{
+};
+
+//------------- Forward declarations of BufferSize ------------------
+
+template <typename T, bool = true>
 size_t BufferSize(const T& val);
 
 template <>
 size_t BufferSize(const std::string& str);
 
-template <class T, size_t N>
+template <class T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
 size_t BufferSize(const std::array<T, N>& v);
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <
+    template <class, class> class Container, class T, class... TArgs,
+    std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
 size_t BufferSize(const Container<T, TArgs...>& vect);
 
 //---------- Forward declarations of DeserializeFromBuffer -----------
 
-template <typename T>
+template <typename T, bool = true>
 void DeserializeFromBuffer(SpanBytesConst& buffer, T& dest);
 
 template <>
 void DeserializeFromBuffer(SpanBytesConst& buffer, std::string& str);
 
-template <class T, size_t N>
+template <class T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
 void DeserializeFromBuffer(SpanBytesConst& buffer, std::array<T, N>& v);
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <
+    template <class, class> class Container, class T, class... TArgs,
+    std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
 void DeserializeFromBuffer(SpanBytesConst& buffer, Container<T, TArgs...>& dest);
 
 //---------- Forward declarations of SerializeIntoBuffer -----------
 
-template <typename T>
+template <typename T, bool = true>
 void SerializeIntoBuffer(SpanBytes& buffer, const T& value);
 
 template <>
 void SerializeIntoBuffer(SpanBytes& buffer, const std::string& str);
 
-template <class T, size_t N>
+template <class T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
 void SerializeIntoBuffer(SpanBytes& buffer, const std::array<T, N>& v);
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <
+    template <class, class> class Container, class T, class... TArgs,
+    std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
 void SerializeIntoBuffer(SpanBytes& buffer, const Container<T, TArgs...>& vect);
 
 //-----------------------------------------------------------------------
@@ -150,8 +183,8 @@ inline void Span<T>::trimFront(size_t offset)
 #endif  // __s390x__
 #if !defined(SERIALIZE_LITTLEENDIAN)
 #if defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)
-#if(defined(__BIG_ENDIAN__) ||                                                           \
-    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+#if (defined(__BIG_ENDIAN__) ||                                                          \
+     (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
 #define SERIALIZE_LITTLEENDIAN 0
 #else
 #define SERIALIZE_LITTLEENDIAN 1
@@ -228,31 +261,6 @@ inline T EndianSwap(T t)
     std::runtime_error("Problem with IndianSwap");
   }
 }
-
-// Check if a Function like this is implemented:
-//
-// template <typename Func> std::string_view TypeDefinition(T&, Func&);
-
-template <typename T, class = void>
-struct has_TypeDefinition : std::false_type
-{
-};
-
-const auto EmptyFuncion = [](const char*, void*) {};
-using EmptyFunc = decltype(EmptyFuncion);
-
-template <typename T1, typename T2>
-using enable_if_same_t = std::enable_if_t<std::is_same_v<T1, T2>>;
-
-template <typename T>
-struct has_TypeDefinition<
-    T, enable_if_same_t<std::string_view,
-                        decltype(TypeDefinition(std::declval<T&>(),
-                                                std::declval<EmptyFunc&>()))>>
-  : std::true_type
-{
-};
-
 template <typename T>
 inline constexpr bool is_number()
 {
@@ -314,7 +322,7 @@ inline constexpr bool is_vector()
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 
-template <typename T>
+template <typename T, bool>
 inline size_t BufferSize(const T& val)
 {
   static_assert(is_number<T>() || has_TypeDefinition<T>(), "Missing TypeDefinition");
@@ -341,13 +349,15 @@ inline size_t BufferSize(const std::string& str)
   return sizeof(StringSize) + str.size();
 }
 
-template <class T, size_t N>
+template <class T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline size_t BufferSize(const std::array<T, N>&)
 {
   return BufferSize(T{}) * N;
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline size_t BufferSize(const Container<T, TArgs...>& vect)
 {
   if constexpr(std::is_trivially_copyable_v<T> && is_vector<Container<T, TArgs...>>())
@@ -369,7 +379,7 @@ inline size_t BufferSize(const Container<T, TArgs...>& vect)
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 
-template <typename T>
+template <typename T, bool>
 inline void DeserializeFromBuffer(SpanBytesConst& buffer, T& dest)
 {
   static_assert(is_number<T>() || has_TypeDefinition<T>(), "Missing TypeDefinition");
@@ -412,7 +422,8 @@ inline void DeserializeFromBuffer(SpanBytesConst& buffer, std::string& dest)
   buffer.trimFront(size);
 }
 
-template <typename T, size_t N>
+template <typename T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline void DeserializeFromBuffer(SpanBytesConst& buffer, std::array<T, N>& dest)
 {
   if(N * BufferSize(T{}) > buffer.size())
@@ -434,7 +445,8 @@ inline void DeserializeFromBuffer(SpanBytesConst& buffer, std::array<T, N>& dest
   }
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline void DeserializeFromBuffer(SpanBytesConst& buffer, Container<T, TArgs...>& dest)
 {
   uint32_t num_values = 0;
@@ -475,7 +487,7 @@ inline void DeserializeFromBuffer(SpanBytesConst& buffer, Container<T, TArgs...>
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 
-template <typename T>
+template <typename T, bool>
 inline void SerializeIntoBuffer(SpanBytes& buffer, T const& value)
 {
   static_assert(is_number<T>() || has_TypeDefinition<T>(), "Missing TypeDefinition");
@@ -488,9 +500,10 @@ inline void SerializeIntoBuffer(SpanBytes& buffer, T const& value)
       throw std::runtime_error("SerializeIntoBuffer: buffer overflow");
     }
 #if SERIALIZE_LITTLEENDIAN == 0
-    *(reinterpret_cast<T*>(buffer.data())) = EndianSwap<T>(value);
+    T swapped = EndianSwap<T>(value);
+    std::memcpy(buffer.data(), &swapped, S);
 #else
-    *(reinterpret_cast<T*>(buffer.data())) = value;
+    std::memcpy(buffer.data(), &value, S);
 #endif
     buffer.trimFront(S);  // NOLINT
   }
@@ -523,7 +536,8 @@ inline void SerializeIntoBuffer(SpanBytes& buffer, std::string const& str)
   buffer.trimFront(size);
 }
 
-template <typename T, size_t N>
+template <typename T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline void SerializeIntoBuffer(SpanBytes& buffer, std::array<T, N> const& vect)
 {
   if(N > std::numeric_limits<uint32_t>::max())
@@ -553,7 +567,8 @@ inline void SerializeIntoBuffer(SpanBytes& buffer, std::array<T, N> const& vect)
   }
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline void SerializeIntoBuffer(SpanBytes& buffer, Container<T, TArgs...> const& vect)
 {
   const auto num_values = static_cast<uint32_t>(vect.size());
diff --git a/data_tamer_cpp/include/data_tamer/custom_types.hpp b/data_tamer_cpp/include/data_tamer/custom_types.hpp
index 10daa42..c9da152 100644
--- a/data_tamer_cpp/include/data_tamer/custom_types.hpp
+++ b/data_tamer_cpp/include/data_tamer/custom_types.hpp
@@ -151,9 +151,6 @@ template <typename T>
 inline CustomSerializerT<T>::CustomSerializerT(std::string type_name)
   : _name(std::move(type_name))
 {
-  static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers a "
-                                                                "template type");
-
   bool is_fixed_size = true;
   GetFixedSize<T>(is_fixed_size, _fixed_size);
   if(!is_fixed_size)
@@ -198,8 +195,6 @@ inline CustomSerializer::Ptr TypesRegistry::getSerializer()
 {
   static_assert(!IsNumericType<T>(), "You don't need to create a serializer for a "
                                      "numerical type.");
-  static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers "
-                                                                "as template type");
 
   std::scoped_lock lk(_mutex);
   T dummy;
@@ -221,8 +216,6 @@ inline CustomSerializer::Ptr TypesRegistry::addType(const std::string& type_name
 {
   static_assert(!IsNumericType<T>(), "You don't need to create a serializer for a "
                                      "numerical type.");
-  static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers "
-                                                                "as template type");
 
   std::scoped_lock lk(_mutex);
   if(skip_if_present && _types.count(type_name) != 0)
diff --git a/data_tamer_cpp/include/data_tamer/values.hpp b/data_tamer_cpp/include/data_tamer/values.hpp
index 3a82d2e..44c5cd1 100644
--- a/data_tamer_cpp/include/data_tamer/values.hpp
+++ b/data_tamer_cpp/include/data_tamer/values.hpp
@@ -9,6 +9,7 @@
 
 namespace DataTamer
 {
+using SerializeMe::has_TypeDefinition;
 
 /**
  * @brief The ValuePtr is a non-owning pointer to
@@ -19,19 +20,23 @@ class ValuePtr
 public:
   ValuePtr() = default;
 
-  template <typename T>
+  template <typename T, bool = true>
   ValuePtr(const T* pointer, CustomSerializer::Ptr type_info = {});
 
-  template <template <class, class> class Container, class T, class... TArgs>
+  template <template <class, class> class Container, class T, class... TArgs,
+            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   ValuePtr(const Container<T, TArgs...>* vect);
 
-  template <template <class, class> class Container, class T, class... TArgs>
+  template <template <class, class> class Container, class T, class... TArgs,
+            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   ValuePtr(const Container<T, TArgs...>* vect, CustomSerializer::Ptr type_info);
 
-  template <typename T, size_t N>
+  template <typename T, size_t N,
+            std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
   ValuePtr(const std::array<T, N>* vect);
 
-  template <typename T, size_t N>
+  template <typename T, size_t N,
+            std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
   ValuePtr(const std::array<T, N>* vect, CustomSerializer::Ptr type_info);
 
   ValuePtr(ValuePtr const& other) = delete;
@@ -70,7 +75,7 @@ class ValuePtr
 //------------------------------------------------------------
 //------------------------------------------------------------
 
-template <typename T>
+template <typename T, bool>
 inline ValuePtr::ValuePtr(const T* pointer, CustomSerializer::Ptr type_info)
   : v_ptr_(pointer)
   , type_(GetBasicType<T>())
@@ -89,7 +94,8 @@ inline ValuePtr::ValuePtr(const T* pointer, CustomSerializer::Ptr type_info)
   }
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline ValuePtr::ValuePtr(const Container<T, TArgs...>* vect)
   : v_ptr_(vect)
   , type_(GetBasicType<T>())
@@ -103,7 +109,8 @@ inline ValuePtr::ValuePtr(const Container<T, TArgs...>* vect)
   get_size_impl_ = [vect]() -> size_t { return SerializeMe::BufferSize(*vect); };
 }
 
-template <template <class, class> class Container, class T, class... TArgs>
+template <template <class, class> class Container, class T, class... TArgs,
+          std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool>>
 inline ValuePtr::ValuePtr(const Container<T, TArgs...>* vect,
                           CustomSerializer::Ptr type_info)
   : v_ptr_(vect)
@@ -137,7 +144,7 @@ inline ValuePtr::ValuePtr(const Container<T, TArgs...>* vect,
   };
 }
 
-template <typename T, size_t N>
+template <typename T, size_t N, std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline ValuePtr::ValuePtr(const std::array<T, N>* array)
   : v_ptr_(array)
   , type_(GetBasicType<T>())
@@ -151,7 +158,7 @@ inline ValuePtr::ValuePtr(const std::array<T, N>* array)
   get_size_impl_ = [array]() { return SerializeMe::BufferSize(*array); };
 }
 
-template <typename T, size_t N>
+template <typename T, size_t N, std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline ValuePtr::ValuePtr(const std::array<T, N>* array, CustomSerializer::Ptr type_info)
   : v_ptr_(array)
   , type_(GetBasicType<T>())
diff --git a/data_tamer_cpp/tests/CMakeLists.txt b/data_tamer_cpp/tests/CMakeLists.txt
index 31bead7..6429aa6 100644
--- a/data_tamer_cpp/tests/CMakeLists.txt
+++ b/data_tamer_cpp/tests/CMakeLists.txt
@@ -6,7 +6,8 @@ if(gtest_vendor_FOUND AND ament_cmake_gtest_FOUND)
     ament_add_gtest(datatamer_test
         dt_tests.cpp
         custom_types_tests.cpp
-        parser_tests.cpp)
+        parser_tests.cpp
+        trait_tests.cpp)
 
     target_include_directories(datatamer_test
         PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
diff --git a/data_tamer_cpp/tests/trait_tests.cpp b/data_tamer_cpp/tests/trait_tests.cpp
new file mode 100644
index 0000000..8495fa8
--- /dev/null
+++ b/data_tamer_cpp/tests/trait_tests.cpp
@@ -0,0 +1,108 @@
+#include "data_tamer/contrib/SerializeMe.hpp"
+#include <gtest/gtest.h>
+#include <vector>
+#include <array>
+
+using namespace SerializeMe;
+
+// non-template type with TypeDefinition
+struct CustomWithTypeDef
+{
+  int a;
+  double b;
+};
+
+template <typename AddField>
+std::string_view TypeDefinition(CustomWithTypeDef&, AddField&)
+{
+  return "CustomWithTypeDef";
+}
+
+// non-template type without TypeDefinition
+struct CustomNoTypeDef
+{
+  int x;
+};
+
+// a template but non-variadic custom type
+template <typename T>
+struct TemplateCustomType
+{
+  T type;
+};
+
+template <typename T, typename AddField>
+std::string_view TypeDefinition(TemplateCustomType<T>&, AddField&)
+{
+  return "TemplateCustomType";
+}
+
+// type with variadic parameters but *not* a container type
+template <typename... Args>
+struct VariadicCustomType
+{
+  int id;
+  std::tuple<Args...> values;
+};
+
+template <typename... Args, typename AddField>
+std::string_view TypeDefinition(VariadicCustomType<Args...>&, AddField&)
+{
+  return "VariadicCustomType";
+}
+
+// check that all the traits work as expected at compile time
+// the below tests run, but are here primarily to ensure compilation works as intended for user-defined types
+// the static asserts are the crux of the test
+static_assert(has_TypeDefinition<CustomWithTypeDef>::value, "CustomWithTypeDef should "
+                                                            "have TypeDefinition");
+static_assert(!has_TypeDefinition<CustomNoTypeDef>::value, "CustomNoTypeDef should not "
+                                                           "have TypeDefinition");
+static_assert(!has_TypeDefinition<std::vector<int>>::value, "std::vector<int> should not "
+                                                            "have TypeDefinition");
+static_assert(!has_TypeDefinition<std::array<double, 3>>::value, "std::array<double, 3> "
+                                                                 "should not have "
+                                                                 "TypeDefinition");
+static_assert(has_TypeDefinition<VariadicCustomType<int, double>>::value, "MyCustomType<"
+                                                                          "int, "
+                                                                          "double> "
+                                                                          "should have "
+                                                                          "TypeDefinitio"
+                                                                          "n");
+
+static_assert(has_TypeDefinition<TemplateCustomType<int>>::value, "TemplateCustomType<"
+                                                                  "int> should have "
+                                                                  "TypeDefinition");
+
+// check that BufferSize works on the types
+TEST(CustomTypeTrait, BufferSize)
+{
+  // container of custom type works because it uses the container overload even though the contained type has no TypeDefinition
+  std::vector<CustomNoTypeDef> c{ { 1 }, { 2 }, { 3 } };
+  EXPECT_NO_THROW(BufferSize(c));
+
+  // std containers of std types
+  std::vector<int> v{ 1, 2, 3 };
+  EXPECT_NO_THROW((BufferSize(v)));
+  std::array<double, 2> arr{ { 4.0, 5.0 } };
+  EXPECT_NO_THROW((BufferSize(arr)));
+
+  // template custom type
+  TemplateCustomType<int> template_type_def_type{ 31415 };
+  EXPECT_NO_THROW((BufferSize(template_type_def_type)));
+
+  // variadic custom type
+  VariadicCustomType<int, double> variadic_type_def_type{ 1, std::make_tuple(2, 3.) };
+  EXPECT_NO_THROW((BufferSize(variadic_type_def_type)));
+
+  // container overload for custom type with TypeDefinition
+  std::vector<CustomWithTypeDef> vector_of_type_def{ { 1, 2. }, { 3, 4. } };
+  EXPECT_NO_THROW((BufferSize(vector_of_type_def)));
+
+  // non-variadic custom types
+  CustomWithTypeDef type_def_type{};
+  EXPECT_NO_THROW((BufferSize(type_def_type)));
+  CustomNoTypeDef no_type_def{};
+  // this wouldn't compile since it isn't in a container and has no type def
+  // BufferSize(no_type_def);
+}