diff --git a/indexer/complex/serdes.hpp b/indexer/complex/serdes.hpp
index 9e1a1b1198..de685e3e9a 100644
--- a/indexer/complex/serdes.hpp
+++ b/indexer/complex/serdes.hpp
@@ -67,32 +67,22 @@ public:
   }
 
 private:
-  using ByteVector = std::vector<uint8_t>;
-
   class V0
   {
   public:
     template <typename Sink>
     static void Serialize(Sink & sink, tree_node::Forest<Ids> const & forest)
     {
-      ByteVector forestBuffer;
-      MemWriter<decltype(forestBuffer)> forestWriter(forestBuffer);
-      WriterSink<decltype(forestWriter)> forestMemSink(forestWriter);
-      forest.ForEachTree([&](auto const & tree) { Serialize(forestMemSink, tree); });
-      coding_utils::WriteCollectionPrimitive(sink, forestBuffer);
+      forest.ForEachTree([&](auto const & tree) { Serialize(sink, tree); });
     }
 
     template <typename Src>
     static bool Deserialize(Src & src, tree_node::Forest<Ids> & forest)
     {
-      ByteVector forestBuffer;
-      coding_utils::ReadCollectionPrimitive(src, std::back_inserter(forestBuffer));
-      MemReader forestReader(forestBuffer.data(), forestBuffer.size());
-      ReaderSource<decltype(forestReader)> forestSrc(forestReader);
-      while (forestSrc.Size() > 0)
+      while (src.Size() > 0)
       {
         tree_node::types::Ptr<Ids> tree;
-        if (!Deserialize(forestSrc, tree))
+        if (!Deserialize(src, tree))
           return false;
 
         forest.Append(tree);
@@ -111,7 +101,7 @@ private:
       });
       WriteVarUint(sink, base);
       tree_node::PreOrderVisit(tree, [&](auto const & node) {
-        coding_utils::DeltaEncode<uint32_t>(sink, node->GetData(), base);
+        coding_utils::DeltaEncode(sink, node->GetData(), base);
         auto const size = base::checked_cast<coding_utils::CollectionSizeType>(node->GetChildren().size());
         WriteVarUint(sink, size);
       });
@@ -127,7 +117,7 @@ private:
           return true;
 
         Ids ids;
-        coding_utils::DeltaDecode<uint32_t>(src, std::back_inserter(ids), base);
+        coding_utils::DeltaDecode(src, std::back_inserter(ids), base);
         tree = tree_node::MakeTreeNode(std::move(ids));
         auto const size = ReadVarUint<coding_utils::CollectionSizeType>(src);
         tree_node::types::Ptrs<Ids> children(size);
diff --git a/indexer/complex/serdes_utils.hpp b/indexer/complex/serdes_utils.hpp
index 84a341472a..fb083a7f2c 100644
--- a/indexer/complex/serdes_utils.hpp
+++ b/indexer/complex/serdes_utils.hpp
@@ -3,10 +3,9 @@
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 
+#include "base/assert.hpp"
 #include "base/checked_cast.hpp"
 
-#include <type_traits>
-
 namespace coding_utils
 {
 namespace detail
@@ -59,7 +58,7 @@ void DeltaEncodeAs(Sink & sink, Cont const & container, Fn && fn)
          ());
 
   auto const contSize = base::checked_cast<CollectionSizeType>(container.size());
-  detail::WriteVarIntegral(sink, contSize);
+  WriteVarUint(sink, contSize);
   if (contSize == 0)
     return;
 
@@ -70,8 +69,8 @@ void DeltaEncodeAs(Sink & sink, Cont const & container, Fn && fn)
   while (++first != last)
   {
     auto const val = fn(*first);
-    auto const delta = base::checked_cast<ValueType>(val - acc);
-    detail::WriteVarIntegral(sink, delta);
+    auto const delta = base::checked_cast<uint64_t>(val - acc);
+    WriteVarUint(sink, delta);
     acc = val;
   }
 }
@@ -81,7 +80,7 @@ void DeltaEncodeAs(Sink & sink, Cont const & container, Fn && fn)
 template <typename ValueType, typename Source, typename OutIt, typename Fn>
 void DeltaDecodeAs(Source & src, OutIt it, Fn && fn)
 {
-  auto contSize = detail::ReadVarIntegral<CollectionSizeType>(src);
+  auto contSize = ReadVarUint<CollectionSizeType>(src);
   if (contSize == 0)
     return;
 
@@ -89,18 +88,18 @@ void DeltaDecodeAs(Source & src, OutIt it, Fn && fn)
   *it++ = fn(sum);
   while (--contSize)
   {
-    sum = sum + detail::ReadVarIntegral<ValueType>(src);
+    sum += base::checked_cast<ValueType>(ReadVarUint<uint64_t>(src));
     *it++ = fn(sum);
   }
 }
 
-template <typename ValueType, typename Sink, typename Cont>
+template <typename Sink, typename Cont, typename ValueType = typename Cont::value_type>
 void DeltaEncode(Sink & sink, Cont const & container, ValueType base = {})
 {
   DeltaEncodeAs<ValueType>(sink, container, [&](ValueType val) { return val - base; });
 }
 
-template <typename ValueType, typename Source, typename OutIt>
+template <typename Source, typename OutIt, typename ValueType = typename OutIt::container_type::value_type>
 void DeltaDecode(Source & src, OutIt it, ValueType base = {})
 {
   DeltaDecodeAs<ValueType>(src, it, [&](ValueType val) { return val + base; });
@@ -110,7 +109,7 @@ void DeltaDecode(Source & src, OutIt it, ValueType base = {})
 template <typename Sink, typename Cont>
 void WriteCollectionPrimitive(Sink & sink, Cont const & container)
 {
-  auto const contSize = static_cast<CollectionSizeType>(container.size());
+  auto const contSize = base::checked_cast<CollectionSizeType>(container.size());
   WriteVarUint(sink, contSize);
   for (auto value : container)
     WriteToSink(sink, value);
diff --git a/indexer/indexer_tests/complex_serdes_utils_tests.cpp b/indexer/indexer_tests/complex_serdes_utils_tests.cpp
index c3f515c29f..e0fa37e73d 100644
--- a/indexer/indexer_tests/complex_serdes_utils_tests.cpp
+++ b/indexer/indexer_tests/complex_serdes_utils_tests.cpp
@@ -21,12 +21,12 @@ void DeltaEncodeDecodelTest(T const & cont, ValueType base = {})
   ByteVector buffer;
   MemWriter<decltype(buffer)> writer(buffer);
   WriterSink<decltype(writer)> sink(writer);
-  coding_utils::DeltaEncode<ValueType>(sink, cont, base);
+  coding_utils::DeltaEncode(sink, cont, base);
 
   MemReader reader(buffer.data(), buffer.size());
   ReaderSource<decltype(reader)> src(reader);
   T res;
-  coding_utils::DeltaDecode<ValueType>(src, std::inserter(res, std::end(res)), base);
+  coding_utils::DeltaDecode(src, std::inserter(res, std::end(res)), base);
   TEST_EQUAL(cont, res, ());
 }