diff --git a/src/v/config/bounded_property.h b/src/v/config/bounded_property.h
index 6ffddda0389f..3bec797c7792 100644
--- a/src/v/config/bounded_property.h
+++ b/src/v/config/bounded_property.h
@@ -121,7 +121,7 @@ class bounded_property : public property<T> {
             // Extract inner value if we are an optional<>,
             // and pass through into numeric_bounds::validate
             using outer_type = std::decay_t<T>;
-            if constexpr (reflection::is_std_optional_v<outer_type>) {
+            if constexpr (reflection::is_std_optional<outer_type>) {
                 if (new_value.has_value()) {
                     return _bounds.validate(new_value.value());
                 } else {
@@ -147,7 +147,7 @@ class bounded_property : public property<T> {
         // rather than via admin API.
 
         // If T is a std::optional, then need to unpack the value.
-        if constexpr (reflection::is_std_optional_v<outer_type>) {
+        if constexpr (reflection::is_std_optional<outer_type>) {
             if (val.has_value()) {
                 return property<T>::update_value(
                   std::move(_bounds.clamp(val.value())));
@@ -189,7 +189,7 @@ class bounded_property : public property<T> {
                 guess -= guess % _bounds.align.value();
             }
         } else {
-            if constexpr (reflection::is_std_optional_v<T>) {
+            if constexpr (reflection::is_std_optional<T>) {
                 if (property<T>::_default.has_value()) {
                     guess = property<T>::_default.value();
                 } else {
@@ -212,4 +212,4 @@ class bounded_property : public property<T> {
     ss::sstring _example;
 };
 
-} // namespace config
\ No newline at end of file
+} // namespace config
diff --git a/src/v/config/property.h b/src/v/config/property.h
index 5577b2441505..39fbe2f8afba 100644
--- a/src/v/config/property.h
+++ b/src/v/config/property.h
@@ -382,7 +382,7 @@ consteval std::string_view property_type_name() {
     } else if constexpr (std::is_same_v<type, bool>) {
         // boolean check must come before is_integral check
         return "boolean";
-    } else if constexpr (reflection::is_std_optional_v<type>) {
+    } else if constexpr (reflection::is_std_optional<type>) {
         return property_type_name<typename type::value_type>();
     } else if constexpr (is_collection<type>) {
         return property_type_name<typename type::value_type>();
@@ -440,7 +440,7 @@ consteval std::string_view property_units_name() {
         return "ms";
     } else if constexpr (std::is_same_v<type, std::chrono::seconds>) {
         return "s";
-    } else if constexpr (reflection::is_std_optional_v<type>) {
+    } else if constexpr (reflection::is_std_optional<type>) {
         return property_units_name<typename type::value_type>();
     } else {
         // This will be transformed to nullopt at runtime: returning
@@ -471,7 +471,7 @@ std::optional<std::string_view> property<T>::units_name() const {
 
 template<typename T>
 bool property<T>::is_nullable() const {
-    if constexpr (reflection::is_std_optional_v<std::decay_t<T>>) {
+    if constexpr (reflection::is_std_optional<std::decay_t<T>>) {
         return true;
     } else {
         return false;
diff --git a/src/v/pandaproxy/parsing/from_chars.h b/src/v/pandaproxy/parsing/from_chars.h
index b95baf409fa6..eedddda802a7 100644
--- a/src/v/pandaproxy/parsing/from_chars.h
+++ b/src/v/pandaproxy/parsing/from_chars.h
@@ -50,11 +50,11 @@ class from_chars {
     using type = std::decay_t<T>;
     using result_type = result<type>;
 
-    static constexpr bool is_optional = reflection::is_std_optional_v<type>;
-    static constexpr bool is_named_type = reflection::is_named_type_v<type>;
+    static constexpr bool is_optional = reflection::is_std_optional<type>;
+    static constexpr bool is_named_type = reflection::is_rp_named_type<type>;
     static constexpr bool is_duration = detail::is_duration_v<type>;
     static constexpr bool is_arithmetic = std::is_arithmetic_v<type>;
-    static constexpr bool is_ss_bool = reflection::is_ss_bool_v<type>;
+    static constexpr bool is_ss_bool = reflection::is_ss_bool_class<type>;
     static constexpr bool is_constructible_from_string_view
       = std::is_constructible_v<type, std::string_view>;
     static constexpr bool is_constructible_from_sstring
diff --git a/src/v/pandaproxy/parsing/httpd.h b/src/v/pandaproxy/parsing/httpd.h
index c725ae5e5969..181675002c6b 100644
--- a/src/v/pandaproxy/parsing/httpd.h
+++ b/src/v/pandaproxy/parsing/httpd.h
@@ -32,7 +32,7 @@ namespace ppj = pandaproxy::json;
 
 template<typename T>
 T parse_param(std::string_view type, std::string_view key, ss::sstring value) {
-    if (!reflection::is_std_optional_v<T> && value.empty()) {
+    if (!reflection::is_std_optional<T> && value.empty()) {
         throw error(
           error_code::empty_param,
           fmt::format("Missing mandatory {} '{}'", type, key));
diff --git a/src/v/reflection/adl.h b/src/v/reflection/adl.h
index 56f39c43d4f1..f3116c47599f 100644
--- a/src/v/reflection/adl.h
+++ b/src/v/reflection/adl.h
@@ -30,10 +30,10 @@ namespace reflection {
 template<typename T>
 struct adl {
     using type = std::remove_reference_t<std::decay_t<T>>;
-    static constexpr bool is_optional = is_std_optional_v<type>;
+    static constexpr bool is_optional = is_std_optional<type>;
     static constexpr bool is_sstring = std::is_same_v<type, ss::sstring>;
-    static constexpr bool is_vector = is_std_vector_v<type>;
-    static constexpr bool is_named_type = is_named_type_v<type>;
+    static constexpr bool is_vector = is_std_vector<type>;
+    static constexpr bool is_named_type = is_rp_named_type<type>;
     static constexpr bool is_iobuf = std::is_same_v<type, iobuf>;
     static constexpr bool is_standard_layout = std::is_standard_layout_v<type>;
     static constexpr bool is_not_floating_point
@@ -41,12 +41,12 @@ struct adl {
     static constexpr bool is_trivially_copyable
       = std::is_trivially_copyable_v<type>;
     static constexpr bool is_enum = std::is_enum_v<T>;
-    static constexpr bool is_ss_bool = is_ss_bool_v<T>;
+    static constexpr bool is_ss_bool = is_ss_bool_class<T>;
     static constexpr bool is_chrono_milliseconds
       = std::is_same_v<type, std::chrono::milliseconds>;
     static constexpr bool is_time_point
       = std::is_same_v<type, ss::lowres_system_clock::time_point>;
-    static constexpr bool is_circular_buffer = is_ss_circular_buffer_v<type>;
+    static constexpr bool is_circular_buffer = is_ss_circular_buffer<type>;
 
     static_assert(
       is_optional || is_sstring || is_vector || is_named_type || is_iobuf
diff --git a/src/v/reflection/type_traits.h b/src/v/reflection/type_traits.h
index e910f7b5cfe4..fa7a815fb769 100644
--- a/src/v/reflection/type_traits.h
+++ b/src/v/reflection/type_traits.h
@@ -22,48 +22,38 @@
 #include <type_traits>
 #include <vector>
 
+namespace detail {
+
+template<typename T, template<typename...> class C>
+struct is_specialization_of : std::false_type {};
+template<template<typename...> class C, typename... Args>
+struct is_specialization_of<C<Args...>, C> : std::true_type {};
+template<typename T, template<typename...> class C>
+inline constexpr bool is_specialization_of_v
+  = is_specialization_of<T, C>::value;
+
+} // namespace detail
+
 namespace reflection {
 
 template<typename T>
-struct is_std_vector : std::false_type {};
-template<typename... Args>
-struct is_std_vector<std::vector<Args...>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_std_vector_v = is_std_vector<T>::value;
+concept is_std_vector = ::detail::is_specialization_of_v<T, std::vector>;
 
 template<typename T>
-struct is_ss_circular_buffer : std::false_type {};
-template<typename... Args>
-struct is_ss_circular_buffer<ss::circular_buffer<Args...>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_ss_circular_buffer_v = is_ss_circular_buffer<T>::value;
+concept is_ss_circular_buffer
+  = ::detail::is_specialization_of_v<T, ss::circular_buffer>;
 
 template<typename T>
-struct is_std_optional : std::false_type {};
-template<typename... Args>
-struct is_std_optional<std::optional<Args...>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_std_optional_v = is_std_optional<T>::value;
+concept is_std_optional = ::detail::is_specialization_of_v<T, std::optional>;
 
 template<typename T>
-struct is_named_type : std::false_type {};
-template<typename T, typename Tag>
-struct is_named_type<named_type<T, Tag>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_named_type_v = is_named_type<T>::value;
+concept is_rp_named_type
+  = ::detail::is_specialization_of_v<T, ::detail::base_named_type>;
 
 template<typename T>
-struct is_ss_bool : std::false_type {};
-template<typename T>
-struct is_ss_bool<ss::bool_class<T>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_ss_bool_v = is_ss_bool<T>::value;
+concept is_ss_bool_class = ::detail::is_specialization_of_v<T, ss::bool_class>;
 
 template<typename T>
-struct is_tristate : std::false_type {};
-template<typename T>
-struct is_tristate<tristate<T>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_tristate_v = is_tristate<T>::value;
+concept is_tristate = ::detail::is_specialization_of_v<T, tristate>;
 
 } // namespace reflection
diff --git a/src/v/serde/serde.h b/src/v/serde/serde.h
index 5fb9c76d00e7..304f1ecba9ca 100644
--- a/src/v/serde/serde.h
+++ b/src/v/serde/serde.h
@@ -99,33 +99,33 @@ using serde_size_t = uint16_t;
 using serde_size_t = uint32_t;
 #endif
 
-template<typename T>
-struct is_fragmented_vector : std::false_type {};
-template<typename T, size_t S>
-struct is_fragmented_vector<fragmented_vector<T, S>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_fragmented_vector_v = is_fragmented_vector<T>::value;
+namespace detail {
 
-template<typename T>
-struct is_std_unordered_map : std::false_type {};
-template<typename... Args>
-struct is_std_unordered_map<std::unordered_map<Args...>> : std::true_type {};
-template<typename T>
-inline constexpr bool is_std_unordered_map_v = is_std_unordered_map<T>::value;
+template<class T, template<class, size_t> class C>
+struct is_specialization_of_sized : std::false_type {};
+template<template<class, size_t> class C, class T, size_t N>
+struct is_specialization_of_sized<C<T, N>, C> : std::true_type {};
+template<typename T, template<class, size_t> class C>
+inline constexpr bool is_specialization_of_sized_v
+  = is_specialization_of_sized<T, C>::value;
+
+} // namespace detail
 
 template<typename T>
-struct is_absl_node_hash_set : std::false_type {};
-template<typename... Args>
-struct is_absl_node_hash_set<absl::node_hash_set<Args...>> : std::true_type {};
+concept is_fragmented_vector
+  = detail::is_specialization_of_sized_v<T, fragmented_vector>;
+
 template<typename T>
-inline constexpr bool is_absl_node_hash_set_v = is_absl_node_hash_set<T>::value;
+concept is_std_unordered_map
+  = ::detail::is_specialization_of_v<T, std::unordered_map>;
 
 template<typename T>
-struct is_absl_node_hash_map : std::false_type {};
-template<typename... Args>
-struct is_absl_node_hash_map<absl::node_hash_map<Args...>> : std::true_type {};
+concept is_absl_node_hash_set
+  = ::detail::is_specialization_of_v<T, absl::node_hash_set>;
+
 template<typename T>
-inline constexpr bool is_absl_node_hash_map_v = is_absl_node_hash_map<T>::value;
+concept is_absl_node_hash_map
+  = ::detail::is_specialization_of_v<T, absl::node_hash_map>;
 
 template<typename T>
 inline constexpr auto const is_serde_compatible_v
@@ -134,18 +134,18 @@ inline constexpr auto const is_serde_compatible_v
          && (!std::is_same_v<float, T> || std::numeric_limits<float>::is_iec559)
          && (!std::is_same_v<double, T> || std::numeric_limits<double>::is_iec559)
          && (!serde_is_enum_v<T> || sizeof(std::decay_t<T>) <= sizeof(serde_enum_serialized_t)))
-    || reflection::is_std_vector_v<T>
-    || reflection::is_named_type_v<T>
-    || reflection::is_ss_bool_v<T>
-    || reflection::is_std_optional_v<T>
+    || reflection::is_std_vector<T>
+    || reflection::is_rp_named_type<T>
+    || reflection::is_ss_bool_class<T>
+    || reflection::is_std_optional<T>
     || std::is_same_v<T, std::chrono::milliseconds>
     || std::is_same_v<T, iobuf>
     || std::is_same_v<T, ss::sstring>
     || std::is_same_v<T, bytes>
-    || is_absl_node_hash_set_v<T>
-    || is_absl_node_hash_map_v<T>
-    || is_std_unordered_map_v<T>
-    || is_fragmented_vector_v<T> || reflection::is_tristate_v<T> || std::is_same_v<T, ss::net::inet_address>;
+    || is_absl_node_hash_set<T>
+    || is_absl_node_hash_map<T>
+    || is_std_unordered_map<T>
+    || is_fragmented_vector<T> || reflection::is_tristate<T> || std::is_same_v<T, ss::net::inet_address>;
 
 template<typename T>
 inline constexpr auto const are_bytes_and_string_different = !(
@@ -234,7 +234,7 @@ void write(iobuf& out, T t) {
             static_assert(sizeof(le_t) == sizeof(Type));
             out.append(reinterpret_cast<char const*>(&le_t), sizeof(le_t));
         }
-    } else if constexpr (reflection::is_std_vector_v<Type>) {
+    } else if constexpr (reflection::is_std_vector<Type>) {
         if (unlikely(t.size() > std::numeric_limits<serde_size_t>::max())) {
             throw serde_exception(fmt_with_ctx(
               ssx::sformat,
@@ -245,9 +245,9 @@ void write(iobuf& out, T t) {
         for (auto& el : t) {
             write(out, std::move(el));
         }
-    } else if constexpr (reflection::is_named_type_v<Type>) {
+    } else if constexpr (reflection::is_rp_named_type<Type>) {
         return write(out, static_cast<typename Type::type>(t));
-    } else if constexpr (reflection::is_ss_bool_v<Type>) {
+    } else if constexpr (reflection::is_ss_bool_class<Type>) {
         write(out, static_cast<int8_t>(bool(t)));
     } else if constexpr (std::is_same_v<Type, std::chrono::milliseconds>) {
         write<int64_t>(out, t.count());
@@ -260,14 +260,14 @@ void write(iobuf& out, T t) {
     } else if constexpr (std::is_same_v<Type, bytes>) {
         write<serde_size_t>(out, t.size());
         out.append(t.data(), t.size());
-    } else if constexpr (reflection::is_std_optional_v<Type>) {
+    } else if constexpr (reflection::is_std_optional<Type>) {
         if (t) {
             write(out, true);
             write(out, std::move(t.value()));
         } else {
             write(out, false);
         }
-    } else if constexpr (is_absl_node_hash_set_v<Type>) {
+    } else if constexpr (is_absl_node_hash_set<Type>) {
         if (unlikely(t.size() > std::numeric_limits<serde_size_t>::max())) {
             throw serde_exception(fmt_with_ctx(
               ssx::sformat,
@@ -278,7 +278,7 @@ void write(iobuf& out, T t) {
         for (auto& e : t) {
             write(out, e);
         }
-    } else if constexpr (is_absl_node_hash_map_v<Type>) {
+    } else if constexpr (is_absl_node_hash_map<Type>) {
         if (unlikely(t.size() > std::numeric_limits<serde_size_t>::max())) {
             throw serde_exception(fmt_with_ctx(
               ssx::sformat,
@@ -290,7 +290,7 @@ void write(iobuf& out, T t) {
             write(out, v.first);
             write(out, std::move(v.second));
         }
-    } else if constexpr (is_std_unordered_map_v<Type>) {
+    } else if constexpr (is_std_unordered_map<Type>) {
         if (unlikely(t.size() > std::numeric_limits<serde_size_t>::max())) {
             throw serde_exception(fmt_with_ctx(
               ssx::sformat,
@@ -302,7 +302,7 @@ void write(iobuf& out, T t) {
             write(out, v.first);
             write(out, std::move(v.second));
         }
-    } else if constexpr (is_fragmented_vector_v<Type>) {
+    } else if constexpr (is_fragmented_vector<Type>) {
         if (unlikely(t.size() > std::numeric_limits<serde_size_t>::max())) {
             throw serde_exception(fmt_with_ctx(
               ssx::sformat,
@@ -313,7 +313,7 @@ void write(iobuf& out, T t) {
         for (auto& el : t) {
             write(out, std::move(el));
         }
-    } else if constexpr (reflection::is_tristate_v<T>) {
+    } else if constexpr (reflection::is_tristate<T>) {
         if (t.is_disabled()) {
             write<int8_t>(out, -1);
         } else if (!t.has_value()) {
@@ -496,16 +496,16 @@ void read_nested(iobuf_parser& in, T& t, std::size_t const bytes_left_limit) {
         } else {
             t = ss::le_to_cpu(in.consume_type<Type>());
         }
-    } else if constexpr (reflection::is_std_vector_v<Type>) {
+    } else if constexpr (reflection::is_std_vector<Type>) {
         using value_type = typename Type::value_type;
         const auto size = read_nested<serde_size_t>(in, bytes_left_limit);
         t.reserve(size);
         for (auto i = 0U; i < size; ++i) {
             t.push_back(read_nested<value_type>(in, bytes_left_limit));
         }
-    } else if constexpr (reflection::is_named_type_v<Type>) {
+    } else if constexpr (reflection::is_rp_named_type<Type>) {
         t = Type{read_nested<typename Type::type>(in, bytes_left_limit)};
-    } else if constexpr (reflection::is_ss_bool_v<Type>) {
+    } else if constexpr (reflection::is_ss_bool_class<Type>) {
         t = Type{read_nested<int8_t>(in, bytes_left_limit) != 0};
     } else if constexpr (std::is_same_v<Type, std::chrono::milliseconds>) {
         t = std::chrono::milliseconds{
@@ -522,12 +522,12 @@ void read_nested(iobuf_parser& in, T& t, std::size_t const bytes_left_limit) {
           read_nested<serde_size_t>(in, bytes_left_limit));
         in.consume_to(str.size(), str.begin());
         t = str;
-    } else if constexpr (reflection::is_std_optional_v<Type>) {
+    } else if constexpr (reflection::is_std_optional<Type>) {
         t = read_nested<bool>(in, bytes_left_limit)
               ? Type{read_nested<typename Type::value_type>(
                 in, bytes_left_limit)}
               : std::nullopt;
-    } else if constexpr (is_absl_node_hash_set_v<Type>) {
+    } else if constexpr (is_absl_node_hash_set<Type>) {
         const auto size = read_nested<serde_size_t>(in, bytes_left_limit);
         t.reserve(size);
         for (auto i = 0U; i < size; ++i) {
@@ -535,7 +535,7 @@ void read_nested(iobuf_parser& in, T& t, std::size_t const bytes_left_limit) {
               in, bytes_left_limit);
             t.emplace(std::move(elem));
         }
-    } else if constexpr (is_absl_node_hash_map_v<Type>) {
+    } else if constexpr (is_absl_node_hash_map<Type>) {
         const auto size = read_nested<serde_size_t>(in, bytes_left_limit);
         t.reserve(size);
         for (auto i = 0U; i < size; ++i) {
@@ -545,7 +545,7 @@ void read_nested(iobuf_parser& in, T& t, std::size_t const bytes_left_limit) {
               in, bytes_left_limit);
             t.emplace(std::move(key), std::move(value));
         }
-    } else if constexpr (is_std_unordered_map_v<Type>) {
+    } else if constexpr (is_std_unordered_map<Type>) {
         const auto size = read_nested<serde_size_t>(in, bytes_left_limit);
         t.reserve(size);
         for (auto i = 0U; i < size; ++i) {
@@ -555,14 +555,14 @@ void read_nested(iobuf_parser& in, T& t, std::size_t const bytes_left_limit) {
               in, bytes_left_limit);
             t.emplace(std::move(key), std::move(value));
         }
-    } else if constexpr (is_fragmented_vector_v<Type>) {
+    } else if constexpr (is_fragmented_vector<Type>) {
         using value_type = typename Type::value_type;
         const auto size = read_nested<serde_size_t>(in, bytes_left_limit);
         for (auto i = 0U; i < size; ++i) {
             t.push_back(read_nested<value_type>(in, bytes_left_limit));
         }
         t.shrink_to_fit();
-    } else if constexpr (reflection::is_tristate_v<T>) {
+    } else if constexpr (reflection::is_tristate<T>) {
         int8_t flag = read_nested<int8_t>(in, bytes_left_limit);
         if (flag == -1) {
             // disabled
diff --git a/src/v/serde/test/fuzz.cc b/src/v/serde/test/fuzz.cc
index 115dc184a9cf..3311f24975a8 100644
--- a/src/v/serde/test/fuzz.cc
+++ b/src/v/serde/test/fuzz.cc
@@ -71,7 +71,7 @@ void init(
            },
            t.template get_generation<Generation>())),
          ...);
-    } else if constexpr (reflection::is_std_optional_v<T>) {
+    } else if constexpr (reflection::is_std_optional<T>) {
         if (
           depth != max_depth
           && gen.get<std::uint8_t>()
@@ -81,7 +81,7 @@ void init(
         } else {
             t = std::nullopt;
         }
-    } else if constexpr (reflection::is_std_vector_v<T>) {
+    } else if constexpr (reflection::is_std_vector<T>) {
         if (depth != max_depth) {
             t.resize(gen.get<uint8_t>() % max_vector_size);
             for (auto& v : t) {