diff --git a/universal/include/userver/formats/common/meta.hpp b/universal/include/userver/formats/common/meta.hpp
index a63cb7653f08..f1af6d610876 100644
--- a/universal/include/userver/formats/common/meta.hpp
+++ b/universal/include/userver/formats/common/meta.hpp
@@ -32,9 +32,14 @@ template <typename Value, typename T>
 using HasConvert =
     decltype(Convert(std::declval<const Value&>(), parse::To<T>{}));
 
+template <typename Value, typename T>
+using HasTryParse =
+    decltype(TryParse(std::declval<const Value&>(), parse::To<T>{}));
+
 template <typename Value>
 using IsFormatValue = typename Value::ParseException;
 
+
 template <class Value, class T>
 constexpr inline bool kHasParse = meta::kIsDetected<HasParse, Value, T>;
 
@@ -44,6 +49,9 @@ constexpr inline bool kHasSerialize = meta::kIsDetected<HasSerialize, Value, T>;
 template <class Value, class T>
 constexpr inline bool kHasConvert = meta::kIsDetected<HasConvert, Value, T>;
 
+template <class Value, class T>
+constexpr inline bool kHasTryParse = meta::kIsDetected<HasTryParse, Value, T>;
+
 }  // namespace impl
 
 /// Used in `Parse` overloads that are templated on `Value`, avoids clashing
diff --git a/universal/include/userver/formats/parse/try_parse.hpp b/universal/include/userver/formats/parse/try_parse.hpp
new file mode 100644
index 000000000000..20ea92db7ac9
--- /dev/null
+++ b/universal/include/userver/formats/parse/try_parse.hpp
@@ -0,0 +1,97 @@
+#pragma once
+#include <type_traits>
+#include <string>
+#include <cstdint>
+#include <limits>
+#include <userver/formats/parse/to.hpp>
+#include <userver/utils/meta.hpp>
+#include <userver/utils/impl/type_list.hpp>
+#include <userver/formats/common/meta.hpp>
+#include <userver/formats/parse/common_containers.hpp>
+
+
+USERVER_NAMESPACE_BEGIN
+
+namespace formats::parse {
+
+namespace impl {
+
+template <typename T, typename Value>
+constexpr inline bool Is(Value&& value) {
+  if constexpr(std::is_same_v<T, bool>) {
+    return value.IsBool();
+  } else if constexpr(meta::kIsInteger<T>) {
+    return (std::is_unsigned_v<T> && sizeof(T) == sizeof(std::uint64_t)) ? value.IsUInt64() : value.IsInt64();
+  } else if constexpr(std::is_convertible_v<T, std::string>) {
+    return value.IsString();
+  } else if constexpr(std::is_convertible_v<T, double>) {
+    return value.IsDouble();
+  } else if constexpr(meta::kIsRange<T>) {
+    return value.IsArray();
+  } else {
+    return value.IsObject();
+  }
+}
+bool CheckInBounds(const auto& x, const auto& min, const auto& max) {
+  if (x < min || x > max) {
+    return false;
+  };
+  return true;
+};
+inline constexpr utils::impl::TypeList<bool, double, std::string> kBaseTypes;
+
+} // namespace impl
+
+
+template <typename T, typename Value>
+constexpr inline std::enable_if_t<
+        utils::impl::AnyOf(utils::impl::IsSameCarried<T>(), impl::kBaseTypes) ||
+        meta::kIsInteger<T>, std::optional<T>>
+TryParse(Value&& value, userver::formats::parse::To<T>) {
+  if(!impl::Is<T>(value)) {
+    return std::nullopt;
+  }
+  return value.template As<T>();
+}
+
+template <typename T, typename Value>
+constexpr inline std::optional<std::optional<T>> TryParse(Value&& value, userver::formats::parse::To<std::optional<T>>) {
+  return TryParse(std::forward<Value>(value), userver::formats::parse::To<T>{});
+}
+template <typename Value>
+constexpr inline std::optional<float> TryParse(Value&& value, userver::formats::parse::To<float>) {
+  auto response = value.template As<double>();
+  if(impl::CheckInBounds(response, std::numeric_limits<float>::lowest(),
+                        std::numeric_limits<float>::max())) {
+    return static_cast<float>(response);
+  };
+  return std::nullopt;
+};
+
+template <typename T, typename Value>
+constexpr inline std::enable_if_t<meta::kIsRange<T> && !meta::kIsMap<T> &&
+                     !std::is_same_v<T, boost::uuids::uuid> &&
+                     !utils::impl::AnyOf(utils::impl::IsConvertableCarried<T>(), impl::kBaseTypes) &&
+                     !std::is_convertible_v<
+                         T&, utils::impl::strong_typedef::StrongTypedefTag&>,
+                 std::optional<T>>
+TryParse(Value&& from, To<T>) {
+  T response;
+  auto inserter = std::inserter(response, response.end());
+  using ValueType = meta::RangeValueType<T>;
+  for(const auto& item : from) {
+    auto insert = TryParse(item, userver::formats::parse::To<ValueType>{});
+    if(!insert) {
+      return std::nullopt;
+    };
+    *inserter = *insert;
+    ++inserter;
+  };
+  return response;
+}
+
+
+
+} // namespace formats::parse
+
+USERVER_NAMESPACE_END
diff --git a/universal/include/userver/formats/universal/common_checks.hpp b/universal/include/userver/formats/universal/common_checks.hpp
new file mode 100644
index 000000000000..a1701ea57488
--- /dev/null
+++ b/universal/include/userver/formats/universal/common_checks.hpp
@@ -0,0 +1,204 @@
+
+#pragma once
+#include <userver/formats/universal/universal.hpp>
+#include <userver/utils/regex.hpp>
+#include <fmt/format.h>
+#include <map>
+
+USERVER_NAMESPACE_BEGIN
+namespace formats::universal::impl {
+
+
+template <auto Value>
+struct Min {
+  static constexpr auto kValue = Value;
+};
+
+template <auto Value>
+struct Max {
+  static constexpr auto kValue = Value;
+};
+
+template <std::size_t Value>
+struct MaxItems {
+  static constexpr auto kValue = Value;
+};
+
+template <std::size_t Value>
+struct MinItems {
+  static constexpr auto kValue = Value;
+};
+
+template <auto Value>
+struct Default {
+  static constexpr auto kValue = Value;
+};
+
+template <utils::ConstexprString Regex>
+struct Pattern {
+  static constexpr auto kValue = Regex;
+};
+
+template <auto... Checks>
+struct Items {
+  static constexpr auto kChecks = std::make_tuple(Checks...);
+};
+
+struct Additional {};
+
+
+template <typename Field, auto Value>
+constexpr inline std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field& field, MaxItems<Value>) {
+  return field.size() <= Value;
+};
+
+template <typename Field, auto Value>
+constexpr inline std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field& field, MinItems<Value>) {
+  return field.size() >= Value;
+};
+
+template <typename Field, auto... Checks>
+constexpr inline std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field& field, Items<Checks...>) {
+  for(const auto& element : field) {
+    if(!(Check(element, Checks) && ...)) {
+      return false;
+    };
+  };
+  return true;
+};
+
+
+template <typename Field, auto Value>
+constexpr inline std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field& field, Max<Value>) noexcept {
+  return Value >= field;
+};
+
+template <typename Field, auto Value>
+constexpr inline std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field& field, Min<Value>) noexcept {
+  return field >= Value;
+};
+
+template <typename Field, auto Value>
+constexpr inline auto Check(const Field&, Default<Value>) noexcept {
+  return true;
+};
+
+template <utils::ConstexprString Regex>
+static const userver::utils::regex kRegex(Regex);
+
+template <utils::ConstexprString Regex>
+constexpr inline auto Check(const std::string& field, Pattern<Regex>) noexcept {
+  return utils::regex_match(field, kRegex<Regex>);
+};
+
+template <typename Field, auto Value>
+constexpr inline auto Check(const std::optional<Field>&, Default<Value>) noexcept {
+  return true;
+};
+
+template <typename Field>
+constexpr inline
+std::enable_if_t<!meta::kIsOptional<Field>, bool>
+Check(const Field&, Additional) noexcept {
+  return true;
+};
+
+template <typename Key, auto Value>
+constexpr inline auto Check(const std::vector<Key>& field, Max<Value>) noexcept {
+  for(const auto& element : field) {
+    if(!(Value <= field)) {
+      return false;
+    };
+  };
+  return true;
+};
+
+template <typename Key, auto Value>
+constexpr inline auto Check(const std::vector<Key>& field, Min<Value>) noexcept {
+  for(const auto& element : field) {
+    if(!(Value >= field)) {
+      return false;
+    };
+  };
+  return true;
+};
+
+template <typename Key, typename Tp, auto Value>
+constexpr inline auto Check(const std::map<Key, Tp>& field, Max<Value>) noexcept {
+  return Value >= field.size();
+};
+
+template <typename Key, typename Tp, auto Value>
+constexpr inline auto Check(const std::unordered_map<Key, Tp>& field, Max<Value>) noexcept {
+  return Value >= field.size();
+};
+
+template <typename Field, typename CheckT>
+constexpr inline bool Check(const std::optional<Field>& field, CheckT check) noexcept {
+  if(field.has_value()) {
+    return Check(*field, check);
+  };
+  return true;
+};
+
+template <typename T, auto I, typename Key, typename Value, auto Maximum>
+constexpr inline auto ErrorMessage(const std::unordered_map<Key, Value>& field, Max<Maximum>) {
+  return fmt::format("Error with field {0} Map size: {1} Maximum Size: {2}", boost::pfr::get_name<I, T>(), field.size(), Maximum);
+};
+
+template <typename T, auto I, typename Field, template <auto> typename Check, auto Value>
+constexpr inline auto ErrorMessage(const Field& field, Check<Value>) {
+  return fmt::format("Error with field {0} Field value: {1} Check Value: {2}", boost::pfr::get_name<I, T>(), field, Value);
+};
+
+
+template <typename T, auto I, typename Value, typename Check>
+constexpr inline auto ErrorMessage(const std::unordered_map<std::string, Value>&, Additional) {
+  return "Error";
+};
+
+template <typename T, auto I, typename Field, typename Check>
+constexpr inline auto ErrorMessage(const Field&, Check) {
+  return "Error";
+};
+
+template <typename T, auto I, typename Field, template <auto> typename Check, auto Value>
+constexpr inline auto ErrorMessage(const std::optional<Field>& field, Check<Value> check) {
+  return ErrorMessage<T, I>(*field, check);
+};
+
+} // namespace formats::universal::impl
+namespace formats::universal {
+template <auto Value>
+inline constexpr impl::Min<Value> Min;
+
+template <auto Value>
+inline constexpr impl::Max<Value> Max;
+
+template <auto Value>
+inline constexpr impl::Default<Value> Default;
+
+template <auto... Params>
+inline constexpr impl::Items<Params...> Items;
+
+
+inline constexpr impl::Additional Additional;
+
+template <utils::ConstexprString Regex>
+inline constexpr impl::Pattern<Regex> Pattern;
+
+template <std::size_t Value>
+inline constexpr impl::MaxItems<Value> MaxItems;
+
+template <std::size_t Value>
+inline constexpr impl::MinItems<Value> MinItems;
+
+} // namespace formats::universal
+
+USERVER_NAMESPACE_END
+
diff --git a/universal/include/userver/formats/universal/universal.hpp b/universal/include/userver/formats/universal/universal.hpp
new file mode 100644
index 000000000000..84b31a9553ae
--- /dev/null
+++ b/universal/include/userver/formats/universal/universal.hpp
@@ -0,0 +1,371 @@
+#pragma once
+#include <userver/utils/impl/type_list.hpp>
+#include <userver/utils/constexpr_string.hpp>
+#include <userver/formats/parse/to.hpp>
+#include <userver/formats/parse/try_parse.hpp>
+#include <userver/formats/parse/common_containers.hpp>
+#include <userver/formats/serialize/to.hpp>
+#include <userver/formats/common/meta.hpp>
+#include <userver/formats/common/items.hpp>
+#include <userver/formats/parse/try_parse.hpp>
+#include <unordered_map>
+#include <boost/pfr/core_name.hpp>
+#include <boost/pfr/core.hpp>
+
+USERVER_NAMESPACE_BEGIN
+namespace formats::universal {
+
+namespace impl {
+
+struct Disabled {};
+
+struct Additional;
+
+template <auto>
+struct Default;
+
+} //namespace impl
+
+template <auto... Params>
+struct Configurator {
+  using kParams = utils::impl::TypeList<decltype(Params)...>;
+};
+
+template <typename T>
+inline static constexpr auto kSerialization = impl::Disabled{};
+
+template <typename T>
+inline static constexpr auto kDeserialization = kSerialization<T>;
+
+namespace impl {
+
+template <auto Needed, auto Value, typename T, typename F>
+consteval auto TransformIfEqual(const T& obj, const F& f) {
+  if constexpr(Needed == Value) {
+    return f(obj);
+  } else {
+    return obj;
+  };
+};
+
+template <typename T, auto I, typename... Params>
+struct FieldParametries {
+  static constexpr auto kIndex = I;
+  using kType = T;
+  using kFieldType = std::remove_cvref_t<decltype(boost::pfr::get<I>(std::declval<T>()))>;
+};
+
+template <typename Field>
+constexpr inline auto Check(const Field&, Disabled) noexcept {
+  return true;
+};
+
+struct NeverToBeUsed;
+template <typename... Ts>
+struct Error : public std::false_type {};
+
+template <> // https://eel.is/c++draft/temp#res.general-6.1
+struct Error<NeverToBeUsed, NeverToBeUsed> : public std::true_type {};
+
+namespace exam {
+
+template <typename Field, typename CheckT>
+constexpr inline bool Check(const Field&, CheckT) {
+  static_assert(Error<Field, CheckT>::value, "Check Not Found "
+      "Probably you forgot to include the "
+      "<userver/formats/universal/common_checks.hpp>");
+  return false;
+};
+
+template <typename T, auto I, typename Field, typename CheckT>
+constexpr inline const char* ErrorMessage(Field&&, CheckT) {
+  static_assert(Error<Field, CheckT>::value, "Error Message Not Found "
+      "Probably you forgot to include the "
+      "<userver/formats/universal/common_checks.hpp>");
+  return "";
+};
+
+template <typename T, auto I, typename Builder, typename Field, typename CheckT>
+constexpr inline auto RunCheckFor(const Builder&, Field&&, CheckT) {
+  static_assert(Error<Field, CheckT>::value, "Check Not Found "
+      "Probably you forgot to include the "
+      "<userver/formats/universal/common_checks.hpp>");
+};
+
+template <typename T, auto I, typename Value, typename Field, typename CheckT>
+constexpr inline auto RunParseCheckFor(Value&&, const Field& field, CheckT check) {
+  using exam::ErrorMessage;
+  if(!Check(field, check)) {
+    throw std::runtime_error(ErrorMessage<T, I>(field, check));
+  };
+};
+
+template <typename T, auto I, typename... Params, typename Builder, typename Field>
+constexpr inline auto RunWrite(Builder& builder, Field&& field) {
+  builder[std::string(boost::pfr::get_name<I, T>())] = std::forward<Field>(field);
+};
+template <typename T, auto I, typename... Params, typename Builder, typename Field>
+constexpr inline auto RunWrite(Builder& builder, const std::optional<Field>& field) {
+  if(field) {
+    return RunWrite<T, I, Params...>(builder, *field);
+  };
+};
+
+template <typename T, auto I, typename... Params, typename Value, typename Field>
+constexpr inline Field Read(Value&& value, parse::To<Field>) {
+  return value[boost::pfr::get_name<I, T>()].template As<Field>();
+};
+
+template <typename T, auto I, typename... Params, typename From, typename Value>
+constexpr inline
+std::enable_if_t<utils::impl::AnyOf(utils::impl::IsSameCarried<Additional>(), utils::impl::TypeList<Params...>{}), std::unordered_map<std::string, Value>>
+Read(const From& value, parse::To<std::unordered_map<std::string, Value>>) {
+  constexpr auto names = boost::pfr::names_as_array<T>();
+  std::unordered_map<std::string, Value> result;
+  for(const auto& [name, value] : common::Items(value)) {
+    if(std::find(names.begin(), names.end(), name) == names.end()) {
+      result[name] = value.template As<Value>();
+    };
+  };
+  return result;
+};
+
+template <typename T, auto I, typename... Params, typename From, typename Value>
+constexpr inline
+std::enable_if_t<utils::impl::AnyOf(utils::impl::IsSameCarried<Additional>(), utils::impl::TypeList<Params...>{}), std::optional<std::unordered_map<std::string, Value>>>
+Read(const From& value, parse::To<std::optional<std::unordered_map<std::string, Value>>>) {
+  return Read<T, I, Params...>(value, parse::To<std::unordered_map<std::string, Value>>{});
+};
+
+template <typename T>
+struct IsDefault : public std::false_type {};
+
+template <auto Value>
+struct IsDefault<Default<Value>> : public std::true_type {};
+
+template <typename T, auto I, typename... Params, typename Value, typename Field>
+constexpr inline
+std::enable_if_t<!utils::impl::anyOf<IsDefault>(utils::impl::TypeList<Params...>{}), std::optional<Field>>
+Read(Value&& value, parse::To<std::optional<Field>>) {
+  using parse::TryParse;
+  static_assert(common::impl::kHasTryParse<Value, Field>, "Not Found Try Parse");
+  return TryParse(value[boost::pfr::get_name<I, T>()], parse::To<Field>{});
+};
+template <typename T, auto I, typename... Params, typename Value, typename Field>
+constexpr inline
+std::enable_if_t<utils::impl::anyOf<IsDefault>(utils::impl::TypeList<Params...>{}), std::optional<Field>>
+Read(Value&& value, parse::To<std::optional<Field>>) {
+  using parse::TryParse;
+  static_assert(common::impl::kHasTryParse<Value, Field>, "Not Found Try Parse");
+  auto response = TryParse(value[boost::pfr::get_name<I, T>()], parse::To<Field>{});
+  if(!response) {
+    return []<typename... Ts, auto DefaultValue, typename... Tss>(Ts..., Default<DefaultValue>, Tss...){
+      return DefaultValue;
+    }(Params{}...);
+  };
+  return response;
+};
+
+template <typename T, auto I, typename... Params, typename Value, typename Field>
+constexpr inline std::optional<Field> Read(Value&& value, parse::To<std::optional<std::optional<Field>>>) {
+  return Read<T, I, Params...>(std::forward<Value>(value), parse::To<std::optional<Field>>{});
+};
+
+
+template <typename T, auto I, typename Builder, typename Field, auto Value>
+constexpr inline auto RunCheckFor(Builder& builder, const std::optional<Field>& field, Default<Value>) {
+  if(!field.has_value()) {
+    builder[std::string(boost::pfr::get_name<I, T>())] = Value;
+  };
+};
+
+
+template <typename T, auto I, typename... Params, typename Builder, typename Value>
+constexpr inline std::enable_if_t<utils::impl::AnyOf(utils::impl::IsSameCarried<Additional>(), utils::impl::TypeList<Params...>{}), void>
+RunWrite(Builder& builder, const std::unordered_map<std::string, Value>& field) {
+  for(const auto& element : field) {
+    builder[element.first] = element.second;
+  };
+};
+
+template <typename T, auto I, typename Builder, typename Field>
+constexpr inline auto RunCheckFor(Builder&, Field&&, Disabled) noexcept {};
+
+template <typename T, auto I, typename Builder, typename Field>
+constexpr inline auto RunCheckFor(Builder&, const std::optional<Field>&, Disabled) noexcept {};
+
+template <typename T, auto I, typename Builder, typename Field, typename CheckT>
+constexpr inline auto RunCheckFor(Builder&, Field&& field, CheckT check) {
+  if(!Check(field, check)) {
+    throw std::runtime_error(ErrorMessage<T, I>(std::forward<Field>(field), check));
+  };
+};
+
+} // namespace exam
+template <typename T, auto I, typename Builder, typename... Params>
+constexpr inline auto UniversalSerializeField(
+     FieldParametries<T, I, Params...>
+    ,Builder& builder
+    ,const T& obj) {
+  const auto& value = boost::pfr::get<I>(obj);
+  using exam::RunCheckFor;
+  using exam::RunWrite;
+  (RunCheckFor<T, I>(builder, value, Params{}), ...);
+  RunWrite<T, I, Params...>(builder, value);
+};
+
+template <typename T, auto I, typename Format, typename... Params>
+constexpr inline auto UniversalParseField(
+     FieldParametries<T, I, Params...>
+    ,Format&& from) {
+  using exam::Read;
+  using exam::RunParseCheckFor;
+  using FieldType = std::remove_cvref_t<decltype(boost::pfr::get<I>(std::declval<T>()))>;
+  auto value = Read<T, I, Params...>(from, userver::formats::parse::To<FieldType>{});
+  (RunParseCheckFor<T, I>(from, value, Params{}), ...);
+  return value;
+};
+
+
+template <typename T, auto I, typename Format, typename... Params>
+constexpr inline std::optional<std::remove_cvref_t<decltype(boost::pfr::get<I>(std::declval<T>()))>>
+UniversalTryParseField(
+     FieldParametries<T, I, Params...>
+    ,Format&& from) noexcept {
+  using FieldType = std::remove_cvref_t<decltype(boost::pfr::get<I>(std::declval<T>()))>;
+  using exam::Check;
+  using exam::Read;
+
+
+  auto val = Read<T, I, Params...>(from, userver::formats::parse::To<std::optional<FieldType>>{});
+  if((Check(val, Params{}) && ...)) {
+    return val;
+  };
+  return std::nullopt;
+};
+
+} // namespace impl
+
+template <typename T, typename... Params>
+class SerializationConfig {
+  public:
+    static consteval auto Create() {
+      return []<auto... I>(std::index_sequence<I...>){
+        return SerializationConfig<T, impl::FieldParametries<T, I>...>{};
+      }(std::make_index_sequence<boost::pfr::tuple_size_v<T>>());
+    };
+
+
+    template <std::size_t I, typename... ConfigElements>
+    consteval auto With(ConfigElements...) const {
+      return SerializationConfig<T, Params...>::AddParamsTo<I, ConfigElements...>();
+    };
+
+    template <utils::ConstexprString field, typename... ConfigElements>
+    consteval auto With(ConfigElements... config) const {
+      constexpr auto names = boost::pfr::names_as_array<T>();
+      constexpr std::size_t index = std::find(names.begin(), names.end(), field) - names.begin();
+      return With<index>(config...);
+    };
+
+    template <std::size_t I, auto... ConfigElements>
+    consteval auto With(Configurator<ConfigElements...>) const {
+      return With<I>(ConfigElements...);
+    };
+
+    template <typename From, std::size_t I>
+    consteval auto FromStruct() {
+      if constexpr(I == boost::pfr::tuple_size_v<From>) {
+        return SerializationConfig<T, Params...>();
+      } else {
+        constexpr auto fieldName = boost::pfr::get_name<I, From>();
+        constexpr auto names = boost::pfr::names_as_array<T>();
+        constexpr std::size_t Index = std::find(names.begin(), names.end(), fieldName) - names.begin();
+        return SerializationConfig<T, Params...>().With<Index>(boost::pfr::get<I>(From{})).template FromStruct<From, I + 1>();
+      };
+    };
+
+    template <typename From>
+    consteval auto FromStruct() {
+      return FromStruct<From, 0>();
+    };
+
+    constexpr SerializationConfig() noexcept {
+      static_assert(sizeof...(Params) == boost::pfr::tuple_size_v<T>, "Use Create");
+    };
+  private:
+    template <auto I, typename... Parameters>
+    static consteval auto AddParamsTo() {
+      return []<auto... Is>(std::index_sequence<Is...>){
+        return SerializationConfig<T, decltype(
+          impl::TransformIfEqual<I, Is>(Params{},
+              []<typename... FieldParams>(impl::FieldParametries<T, I, FieldParams...>){
+            return impl::FieldParametries<T, I, FieldParams..., Parameters...>();
+          })
+        )...>();
+      }(std::make_index_sequence<sizeof...(Params)>());
+    };
+
+
+};
+
+
+} // namespace formats::universal
+namespace formats::parse {
+
+template <typename Format, typename T>
+constexpr inline
+std::enable_if_t<!std::is_same_v<decltype(universal::kDeserialization<std::remove_cvref_t<T>>), const universal::impl::Disabled>, T>
+Parse(Format&& from,
+    To<T>) {
+  using Config = std::remove_const_t<decltype(universal::kDeserialization<std::remove_cvref_t<T>>)>;
+  using Type = std::remove_cvref_t<T>;
+  return [from = std::forward<Format>(from)]<typename... Params>(universal::SerializationConfig<Type, Params...>){
+    return T{universal::impl::UniversalParseField(Params{}, std::forward<Format>(from))...};
+  }(Config{});
+};
+
+template <typename Format, typename T>
+constexpr inline
+std::enable_if_t<!std::is_same_v<decltype(universal::kDeserialization<std::remove_cvref_t<T>>), const universal::impl::Disabled>, std::optional<T>>
+TryParse(Format&& from,
+    To<T>) {
+  using Config = std::remove_const_t<decltype(universal::kDeserialization<std::remove_cvref_t<T>>)>;
+  using Type = std::remove_cvref_t<T>;
+  return [&]<typename... Params>(universal::SerializationConfig<Type, Params...>) -> std::optional<T> {
+    auto fields = std::make_tuple(universal::impl::UniversalTryParseField(Params{}, from)...);
+    constexpr auto fieldsCount = boost::pfr::tuple_size_v<T>;
+    if([&]<auto... I>(std::index_sequence<I...>){
+      return (std::get<I>(fields) && ...);
+    }(std::make_index_sequence<fieldsCount>())) {
+      return [&]<auto... I>(std::index_sequence<I...>){
+        return T{*std::get<I>(fields)...};
+      }(std::make_index_sequence<fieldsCount>());
+    };
+    return std::nullopt;
+  }(Config{});
+};
+
+} // namespace formats::parse
+
+namespace formats::serialize {
+
+template <typename T, typename Value>
+inline constexpr
+std::enable_if_t<!std::is_same_v<decltype(universal::kSerialization<std::remove_cvref_t<T>>), const universal::impl::Disabled>, Value>
+Serialize(T&& obj,
+    serialize::To<Value>) {
+  using Config = std::remove_const_t<decltype(universal::kSerialization<std::remove_cvref_t<T>>)>;
+  using Type = std::remove_cvref_t<T>;
+  return [&]<typename... Params>
+      (universal::SerializationConfig<Type, Params...>){
+    typename Value::Builder builder;
+    (universal::impl::UniversalSerializeField(Params{}, builder, obj), ...);
+    return builder.ExtractValue();
+  }(Config{});
+};
+
+} // namespace formats::serialize
+
+USERVER_NAMESPACE_END
+
diff --git a/universal/include/userver/utils/constexpr_string.hpp b/universal/include/userver/utils/constexpr_string.hpp
new file mode 100644
index 000000000000..81b946fa33e2
--- /dev/null
+++ b/universal/include/userver/utils/constexpr_string.hpp
@@ -0,0 +1,59 @@
+#pragma once
+#include <algorithm>
+#include <string>
+USERVER_NAMESPACE_BEGIN
+
+namespace utils {
+
+template <std::size_t Size>
+struct ConstexprString {
+
+  static constexpr auto kSize = Size;
+  constexpr operator std::string_view() const {
+    return std::string_view{this->contents_.data(), Size - 1};
+  };
+  constexpr auto c_str() const -> const char* {
+    return this->contents_.data();
+  };
+  constexpr std::size_t size() const {
+    return Size - 1;
+  };
+  constexpr const char* data() const {
+    return this->contents_.begin();
+  };
+
+  constexpr operator char&() const {
+    return this->contents_.data();
+  };
+
+  friend constexpr bool operator==(const ConstexprString& string, const char* other) {
+    return std::string_view(string) == std::string_view(other);
+  };
+  template <typename Stream>
+  friend constexpr auto& operator<<(Stream& stream, const ConstexprString& string) {
+    stream << static_cast<std::string_view>(string);
+    return stream;
+  };
+
+  constexpr ConstexprString(const char (&str)[Size]) noexcept {
+    std::copy_n(str, Size, std::begin(this->contents_));
+  };
+  constexpr ConstexprString(std::array<char, Size> data) noexcept : contents_(data) {};
+  template <std::size_t OtherSize>
+  constexpr ConstexprString<Size + OtherSize> operator+(const ConstexprString<OtherSize>& other) const noexcept {
+    return
+        [&]<auto... I, auto... I2>(std::index_sequence<I...>, std::index_sequence<I2...>){
+      return ConstexprString<Size + OtherSize>({this->contents_[I]..., other.contents_[I2]...});
+    }(std::make_index_sequence<Size>(), std::make_index_sequence<OtherSize>());
+  };
+  template <std::size_t OtherSize>
+  constexpr ConstexprString<Size + OtherSize> operator+(const char(&str)[OtherSize]) const noexcept {
+    return *this + ConstexprString<OtherSize>{str};
+  };
+  std::array<char, Size> contents_;
+};
+template <std::size_t n>
+ConstexprString(char const (&)[n]) -> ConstexprString<n>;
+} // namespace utils
+USERVER_NAMESPACE_END
+
diff --git a/universal/include/userver/utils/impl/type_list.hpp b/universal/include/userver/utils/impl/type_list.hpp
new file mode 100644
index 000000000000..eaf71d031211
--- /dev/null
+++ b/universal/include/userver/utils/impl/type_list.hpp
@@ -0,0 +1,46 @@
+#pragma once
+#include <type_traits>
+
+
+USERVER_NAMESPACE_BEGIN
+
+namespace utils::impl {
+
+template <typename... T>
+struct TypeList {};
+
+
+template <typename... Ts>
+consteval auto size(TypeList<Ts...>) {
+  return sizeof...(Ts);
+}
+
+
+template <template <typename...> typename Check, typename... Ts>
+consteval auto anyOf(TypeList<Ts...>) {
+  return (Check<Ts>::value || ...);
+}
+
+
+template <typename Check, typename... Ts>
+constexpr auto AnyOf(Check check, TypeList<Ts...>) {
+  return (check(std::type_identity<Ts>()) || ...);
+}
+
+template <typename T>
+consteval auto IsSameCarried() {
+  return []<typename T2>(std::type_identity<T2>){
+    return std::is_same_v<T, T2>;
+  };
+}
+template <typename T>
+consteval auto IsConvertableCarried() {
+  return []<typename T2>(std::type_identity<T2>){
+    return std::is_convertible_v<T, T2>;
+  };
+}
+
+} // namespace utils::impl
+
+USERVER_NAMESPACE_END
+
diff --git a/universal/src/formats/json/universal_test.cpp b/universal/src/formats/json/universal_test.cpp
new file mode 100644
index 000000000000..155f05c630b5
--- /dev/null
+++ b/universal/src/formats/json/universal_test.cpp
@@ -0,0 +1,206 @@
+#include <gtest/gtest.h>
+#include <userver/formats/universal/universal.hpp>
+#include <userver/formats/universal/common_checks.hpp>
+#include <userver/formats/json.hpp>
+
+
+USERVER_NAMESPACE_BEGIN
+
+struct SomeStruct {
+  int field1;
+  int field2;
+  constexpr auto operator==(const SomeStruct& other) const noexcept {
+    return (this->field1 == other.field1) && (this->field2 == other.field2);
+  };
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct> =
+    SerializationConfig<SomeStruct>::Create();
+
+TEST(Serialize, Basic) {
+  SomeStruct a{10, 100};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(formats::json::ToString(json), "{\"field1\":10,\"field2\":100}");
+};
+
+TEST(Parse, Basic) {
+  const auto json = formats::json::FromString("{\"field1\":10,\"field2\":100}");
+  const auto fromJson = json.As<SomeStruct>();
+  constexpr SomeStruct valid{10, 100};
+  EXPECT_EQ(fromJson, valid);
+};
+
+TEST(TryParse, Basic) {
+  const auto json = formats::json::FromString("{\"field1\":10,\"field2\":100}");
+  const auto json2 = formats::json::FromString("{\"field1\":10,\"field3\":100}");
+  const auto json3 = formats::json::FromString("{\"field1\":10,\"field2\":\"100\"}");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<SomeStruct>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct>{}), false);
+};
+
+
+struct SomeStruct2 {
+  std::optional<int> field1;
+  std::optional<int> field2;
+  std::optional<int> field3;
+  constexpr bool operator==(const SomeStruct2& other) const noexcept {
+    return this->field1 == other.field1 && this->field2 == other.field2 && this->field3 == other.field3;
+  };
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct2> =
+    SerializationConfig<SomeStruct2>::Create()
+    .With<"field1">(Default<114>);
+
+
+TEST(Serialize, Optional) {
+  SomeStruct2 a{{}, 100, {}};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(json, formats::json::FromString("{\"field1\":114,\"field2\":100}"));
+};
+
+TEST(Parse, Optional) {
+  constexpr SomeStruct2 valid{{114}, {}, {}};
+  const auto json = formats::json::FromString("{}");
+  EXPECT_EQ(json.As<SomeStruct2>(), valid);
+};
+
+TEST(TryParse, Optional) {
+  constexpr SomeStruct2 valid{{114}, {}, {}};
+  const auto json = formats::json::FromString("{}");
+  EXPECT_EQ(formats::parse::TryParse(json, formats::parse::To<SomeStruct2>{}), valid);
+};
+
+
+struct SomeStruct3 {
+  std::unordered_map<std::string, int> field;
+  auto operator==(const SomeStruct3& other) const noexcept {
+    return this->field == other.field;
+  };
+};
+
+struct SomeStruct3Description {
+  formats::universal::Configurator<formats::universal::Additional> field;
+};
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct3> =
+    SerializationConfig<SomeStruct3>::Create()
+    .FromStruct<SomeStruct3Description>();
+
+TEST(Serialize, Additional) {
+  std::unordered_map<std::string, int> value;
+  value["data1"] = 1;
+  value["data2"] = 2;
+  SomeStruct3 a{value};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(json, formats::json::FromString("{\"data1\":1,\"data2\":2}"));
+};
+
+
+
+TEST(Parse, Additional) {
+  std::unordered_map<std::string, int> value;
+  value["data1"] = 1;
+  value["data2"] = 2;
+  SomeStruct3 valid{value};
+  const auto json = formats::json::FromString("{\"data1\":1,\"data2\":2}");
+  const auto fromJson = json.As<SomeStruct3>();
+  EXPECT_EQ(valid, fromJson);
+};
+
+
+TEST(TryParse, Additional) {
+  const auto json = formats::json::FromString("{\"data1\":1,\"data2\":2}");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<SomeStruct3>{}), true);
+};
+
+struct SomeStruct4 {
+  int field;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct4> =
+    SerializationConfig<SomeStruct4>::Create()
+    .With<"field">(Max<120>, Min<10>);
+
+
+
+
+TEST(TryParse, MinMax) {
+  const auto json = formats::json::FromString("{\"field\":1}");
+  const auto json2 = formats::json::FromString("{\"field\":11}");
+  const auto json3 = formats::json::FromString("{\"field\":121}");
+
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<SomeStruct4>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct4>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct4>{}), false);
+};
+
+
+
+struct SomeStruct5 {
+  std::string field;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct5> =
+    SerializationConfig<SomeStruct5>::Create()
+    .With<"field">(Pattern<"^[0-9]+$">);
+
+TEST(TryParse, Pattern) {
+  const auto json = formats::json::FromString(R"({"field":"1234412"})");
+  const auto json2 = formats::json::FromString(R"({"field":"abcdefgh"})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<SomeStruct5>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct5>{}), false);
+};
+
+
+TEST(TryParse, null) {
+  const auto json = formats::json::FromString("null");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, userver::formats::parse::To<std::optional<int>>{}), true);
+};
+
+struct SomeStruct6 {
+  std::vector<std::vector<int>> field;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct6> =
+    SerializationConfig<SomeStruct6>::Create()
+    .With<"field">(MinItems<2>, Items<MinItems<1>, Items<Min<10>>>);
+
+TEST(TryParse, Arrays) {
+  const auto json = formats::json::FromString(R"({"field":[[10], [20]]})");
+  const auto json2 = formats::json::FromString(R"({"field":[["10"], [20]]})");
+  const auto json3 = formats::json::FromString(R"({"field":[[9], [20]]})");
+  const auto json4 = formats::json::FromString(R"({"field":[[], []]})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json,  formats::parse::To<SomeStruct6>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct6>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct6>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json4, formats::parse::To<SomeStruct6>{}), false);
+};
+
+struct SomeStruct7  {
+  int value;
+  std::vector<SomeStruct7> children;
+  inline bool operator==(const SomeStruct7& other) const {
+    return this->value == other.value && this->children == other.children;
+  };
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct7> =
+    SerializationConfig<SomeStruct7>::Create();
+
+
+TEST(Parse, Recursive) {
+  SomeStruct7 valid{1, {{2, {}}}};
+  const auto json = formats::json::FromString(R"({"value":1,"children":[{"value":2,"children":[]}]})");
+  const auto fromJson = json.As<SomeStruct7>();
+  EXPECT_EQ(fromJson, valid);
+};
+
+USERVER_NAMESPACE_END