diff --git a/indexer/CMakeLists.txt b/indexer/CMakeLists.txt
index c401eba51c..3fb034ee68 100644
--- a/indexer/CMakeLists.txt
+++ b/indexer/CMakeLists.txt
@@ -26,6 +26,9 @@ set(
   classificator.hpp
   classificator_loader.cpp
   classificator_loader.hpp
+  complex/serdes.cpp
+  complex/serdes.hpp
+  complex/serdes_utils.hpp
   complex/tree_node.hpp
   cuisines.cpp
   cuisines.hpp
diff --git a/indexer/complex/serdes.cpp b/indexer/complex/serdes.cpp
new file mode 100644
index 0000000000..42cad0cad0
--- /dev/null
+++ b/indexer/complex/serdes.cpp
@@ -0,0 +1,7 @@
+#include "indexer/complex/serdes.hpp"
+
+namespace complex
+{
+// static
+ComplexSerdes::Version const ComplexSerdes::kLatestVersion = Version::V0;
+}  // namespace complex
diff --git a/indexer/complex/serdes.hpp b/indexer/complex/serdes.hpp
new file mode 100644
index 0000000000..9e1a1b1198
--- /dev/null
+++ b/indexer/complex/serdes.hpp
@@ -0,0 +1,165 @@
+#pragma once
+
+#include "indexer/complex/serdes_utils.hpp"
+#include "indexer/complex/tree_node.hpp"
+
+#include "coding/reader.hpp"
+#include "coding/varint.hpp"
+#include "coding/writer.hpp"
+
+#include "base/logging.hpp"
+#include "base/stl_helpers.hpp"
+
+#include <string>
+#include <vector>
+
+#include <boost/optional.hpp>
+
+namespace complex
+{
+class ComplexSerdes
+{
+public:
+  using Ids = std::vector<uint32_t>;
+
+  enum class Version : uint8_t
+  {
+    // There aren't optimized serialization and deserialization. It's experimental verison.
+    // todo(m.andrianov): Explore better ways for serialization and deserialization.
+    V0,
+  };
+
+  static Version const kLatestVersion;
+
+  template <typename Sink>
+  static void Serialize(Sink & sink, tree_node::Forest<Ids> const & forest)
+  {
+    SerializeLatestVersion(sink);
+    Serialize(sink, kLatestVersion, forest);
+  }
+
+  template <typename Reader>
+  static bool Deserialize(Reader & reader, tree_node::Forest<Ids> & forest)
+  {
+    ReaderSource<decltype(reader)> src(reader);
+    auto const version = DeserializeVersion(src);
+    return version ? Deserialize(src, *version, forest) : false;
+  }
+
+  template <typename Sink>
+  static void Serialize(Sink & sink, Version version, tree_node::Forest<Ids> const & forest)
+  {
+    switch (version)
+    {
+    case Version::V0: V0::Serialize(sink, forest); break;
+    default: UNREACHABLE();
+    }
+  }
+
+  template <typename Src>
+  static bool Deserialize(Src & src, Version version, tree_node::Forest<Ids> & forest)
+  {
+    switch (version)
+    {
+    case Version::V0: return V0::Deserialize(src, forest);
+    default: UNREACHABLE();
+    }
+  }
+
+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);
+    }
+
+    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)
+      {
+        tree_node::types::Ptr<Ids> tree;
+        if (!Deserialize(forestSrc, tree))
+          return false;
+
+        forest.Append(tree);
+      }
+      return true;
+    }
+
+  private:
+    template <typename Sink>
+    static void Serialize(Sink & sink, tree_node::types::Ptr<Ids> const & tree)
+    {
+      uint32_t const base = tree_node::Min(tree, [](auto const & data) {
+        auto const it = std::min_element(std::cbegin(data), std::cend(data));
+        CHECK(it != std::cend(data), ());
+        return *it;
+      });
+      WriteVarUint(sink, base);
+      tree_node::PreOrderVisit(tree, [&](auto const & node) {
+        coding_utils::DeltaEncode<uint32_t>(sink, node->GetData(), base);
+        auto const size = base::checked_cast<coding_utils::CollectionSizeType>(node->GetChildren().size());
+        WriteVarUint(sink, size);
+      });
+    }
+
+    template <typename Src>
+    static bool Deserialize(Src & src, tree_node::types::Ptr<Ids> & tree)
+    {
+      auto const base = ReadVarUint<uint32_t>(src);
+      std::function<bool(tree_node::types::Ptr<Ids> &)> deserializeTree;
+      deserializeTree = [&](auto & tree) {
+        if (src.Size() == 0)
+          return true;
+
+        Ids ids;
+        coding_utils::DeltaDecode<uint32_t>(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);
+        for (auto & n : children)
+        {
+          if (!deserializeTree(n))
+            return false;
+
+          n->SetParent(tree);
+        }
+        tree->SetChildren(std::move(children));
+        return true;
+      };
+      return deserializeTree(tree);
+    }
+  };
+
+  template <typename Sink>
+  static void SerializeLatestVersion(Sink & sink)
+  {
+    WriteToSink(sink, base::Underlying(kLatestVersion));
+  }
+
+  template <typename Src>
+  static boost::optional<Version> DeserializeVersion(Src & src)
+  {
+    if (src.Size() < sizeof(kLatestVersion))
+    {
+      LOG(LERROR, ("Unable to deserialize complexes: wrong header version."));
+      return {};
+    }
+    return static_cast<Version>(ReadPrimitiveFromSource<std::underlying_type<Version>::type>(src));
+  }
+};
+}  // namespace complex
diff --git a/indexer/complex/serdes_utils.hpp b/indexer/complex/serdes_utils.hpp
new file mode 100644
index 0000000000..84a341472a
--- /dev/null
+++ b/indexer/complex/serdes_utils.hpp
@@ -0,0 +1,129 @@
+#pragma once
+
+#include "coding/reader.hpp"
+#include "coding/varint.hpp"
+
+#include "base/checked_cast.hpp"
+
+#include <type_traits>
+
+namespace coding_utils
+{
+namespace detail
+{
+// WriteVarIntegral is abstraction over WriteVarUint and WriteVarInt functions.
+// WriteVarIntegral may be used in generic code.
+template <
+    typename T, typename Sink,
+    typename std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int> = 0>
+void WriteVarIntegral(Sink & dst, T value)
+{
+  WriteVarUint(dst, value);
+}
+template <
+    typename T, typename Sink,
+    typename std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int> = 0>
+void WriteVarIntegral(Sink & dst, T value)
+{
+  WriteVarInt(dst, value);
+}
+
+// ReadVarIntegral is abstraction over ReadVarUint and ReadVarInt functions.
+// ReadVarIntegral may be used in generic code.
+template <
+    typename T, typename Source,
+    typename std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int> = 0>
+T ReadVarIntegral(Source & src)
+{
+  return ReadVarUint<T>(src);
+}
+template <
+    typename T, typename Source,
+    typename std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int> = 0>
+T ReadVarIntegral(Source & src)
+{
+  return ReadVarInt<T>(src);
+}
+}  // namespace detail
+
+// Type of collection size. It used for reading and writing collections.
+using CollectionSizeType = uint32_t;
+
+// DeltaEncodeAs encodes data in the form of differences between sequential data.
+// It required sorted |container|. |fn| may used used to access structure fields or data modification.
+template <typename ValueType, typename Sink, typename Cont, typename Fn>
+void DeltaEncodeAs(Sink & sink, Cont const & container, Fn && fn)
+{
+  ASSERT((std::is_sorted(std::cbegin(container), std::cend(container),
+                         [&](auto const & lhs, auto const & rhs) { return fn(lhs) < fn(rhs); })),
+         ());
+
+  auto const contSize = base::checked_cast<CollectionSizeType>(container.size());
+  detail::WriteVarIntegral(sink, contSize);
+  if (contSize == 0)
+    return;
+
+  auto first = std::begin(container);
+  auto const last = std::end(container);
+  auto acc = fn(*first);
+  detail::WriteVarIntegral(sink, acc);
+  while (++first != last)
+  {
+    auto const val = fn(*first);
+    auto const delta = base::checked_cast<ValueType>(val - acc);
+    detail::WriteVarIntegral(sink, delta);
+    acc = val;
+  }
+}
+
+// DeltaDecodeAs decodes data from the form of differences between sequential data.
+// |fn| may used used to initialize an object or data modification.
+template <typename ValueType, typename Source, typename OutIt, typename Fn>
+void DeltaDecodeAs(Source & src, OutIt it, Fn && fn)
+{
+  auto contSize = detail::ReadVarIntegral<CollectionSizeType>(src);
+  if (contSize == 0)
+    return;
+
+  auto sum = detail::ReadVarIntegral<ValueType>(src);
+  *it++ = fn(sum);
+  while (--contSize)
+  {
+    sum = sum + detail::ReadVarIntegral<ValueType>(src);
+    *it++ = fn(sum);
+  }
+}
+
+template <typename ValueType, typename Sink, typename Cont>
+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>
+void DeltaDecode(Source & src, OutIt it, ValueType base = {})
+{
+  DeltaDecodeAs<ValueType>(src, it, [&](ValueType val) { return val + base; });
+}
+
+// WriteCollectionPrimitive writes collection. It used WriteToSink function.
+template <typename Sink, typename Cont>
+void WriteCollectionPrimitive(Sink & sink, Cont const & container)
+{
+  auto const contSize = static_cast<CollectionSizeType>(container.size());
+  WriteVarUint(sink, contSize);
+  for (auto value : container)
+    WriteToSink(sink, value);
+}
+
+// ReadCollectionPrimitive reads collection. It used ReadPrimitiveFromSource function.
+template <typename Source, typename OutIt>
+void ReadCollectionPrimitive(Source & src, OutIt it)
+{
+  using ValueType = typename OutIt::container_type::value_type;
+
+  auto size = ReadVarUint<CollectionSizeType>(src);
+  while (size--)
+    *it++ = ReadPrimitiveFromSource<ValueType>(src);
+}
+}  // namespace coding_utils
diff --git a/indexer/complex/tree_node.hpp b/indexer/complex/tree_node.hpp
index d04157a220..c1c6fd616c 100644
--- a/indexer/complex/tree_node.hpp
+++ b/indexer/complex/tree_node.hpp
@@ -2,7 +2,9 @@
 
 #include <algorithm>
 #include <memory>
+#include <limits>
 #include <sstream>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -196,6 +198,16 @@ size_t CountIf(types::Ptr<Data> const & node, Fn && fn)
   return count;
 }
 
+template <typename Data, typename Fn>
+decltype(auto) Min(types::Ptr<Data> const & node, Fn && fn)
+{
+  auto m = std::numeric_limits<decltype(fn(node->GetData()))>::max();
+  PreOrderVisit(node, [&](auto const & node) {
+    m = std::min(fn(node->GetData()), m);
+  });
+  return m;
+}
+
 template <typename Data>
 void Print(types::Ptr<Data> const & node, std::ostream & stream,
            std::string prefix = "", bool isTail = true)
diff --git a/indexer/indexer_tests/CMakeLists.txt b/indexer/indexer_tests/CMakeLists.txt
index 8a870f52e9..813957b949 100644
--- a/indexer/indexer_tests/CMakeLists.txt
+++ b/indexer/indexer_tests/CMakeLists.txt
@@ -11,6 +11,8 @@ set(
   checker_test.cpp
   cities_boundaries_serdes_tests.cpp
   classificator_tests.cpp
+  complex_serdes_tests.cpp
+  complex_serdes_utils_tests.cpp
   data_source_test.cpp
   drules_selector_parser_test.cpp
   editable_map_object_test.cpp
diff --git a/indexer/indexer_tests/complex_serdes_tests.cpp b/indexer/indexer_tests/complex_serdes_tests.cpp
new file mode 100644
index 0000000000..45560cf3d8
--- /dev/null
+++ b/indexer/indexer_tests/complex_serdes_tests.cpp
@@ -0,0 +1,67 @@
+#include "testing/testing.hpp"
+
+#include "indexer/complex/serdes.hpp"
+#include "indexer/complex/tree_node.hpp"
+
+#include "coding/reader.hpp"
+#include "coding/writer.hpp"
+
+namespace
+{
+using ByteVector = std::vector<uint8_t>;
+
+decltype(auto) GetForest()
+{
+  auto tree1 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({1, 2, 3});
+  auto node11 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({11, 12, 13});
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({111}), node11);
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({112, 113}), node11);
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({114}), node11);
+  tree_node::Link(node11, tree1);
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({6, 7}), tree1);
+
+  auto tree2 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({9});
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({21, 22, 23}), tree2);
+  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({24, 25}), tree2);
+
+  tree_node::Forest<complex::ComplexSerdes::Ids> forest;
+  forest.Append(tree1);
+  forest.Append(tree2);
+  return forest;
+}
+
+UNIT_TEST(Complex_SerdesV0)
+{
+  auto const expectedForest = GetForest();
+
+  ByteVector buffer;
+  MemWriter<decltype(buffer)> writer(buffer);
+  WriterSink<decltype(writer)> sink(writer);
+  complex::ComplexSerdes::Serialize(sink, complex::ComplexSerdes::Version::V0, expectedForest);
+
+  MemReader reader(buffer.data(), buffer.size());
+  ReaderSource<decltype(reader)> src(reader);
+  tree_node::Forest<complex::ComplexSerdes::Ids> forest;
+  TEST(complex::ComplexSerdes::Deserialize(src, complex::ComplexSerdes::Version::V0, forest), ());
+  LOG(LINFO, (forest));
+  LOG(LINFO, (expectedForest));
+  TEST_EQUAL(forest, expectedForest, ());
+}
+
+UNIT_TEST(Complex_Serdes)
+{
+  auto const expectedForest = GetForest();
+
+  ByteVector buffer;
+  MemWriter<decltype(buffer)> writer(buffer);
+  WriterSink<decltype(writer)> sink(writer);
+  complex::ComplexSerdes::Serialize(sink, expectedForest);
+
+  MemReader reader(buffer.data(), buffer.size());
+  tree_node::Forest<complex::ComplexSerdes::Ids> forest;
+  TEST(complex::ComplexSerdes::Deserialize(reader, forest), ());
+  LOG(LINFO, (forest));
+  LOG(LINFO, (expectedForest));
+  TEST_EQUAL(forest, expectedForest, ());
+}
+}  // namespace
diff --git a/indexer/indexer_tests/complex_serdes_utils_tests.cpp b/indexer/indexer_tests/complex_serdes_utils_tests.cpp
new file mode 100644
index 0000000000..c3f515c29f
--- /dev/null
+++ b/indexer/indexer_tests/complex_serdes_utils_tests.cpp
@@ -0,0 +1,116 @@
+#include "testing/testing.hpp"
+
+#include "indexer/complex/serdes_utils.hpp"
+
+#include "coding/reader.hpp"
+#include "coding/writer.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <list>
+#include <set>
+#include <vector>
+
+namespace
+{
+using ByteVector = std::vector<uint8_t>;
+
+template <typename T, typename ValueType = typename T::value_type>
+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);
+
+  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);
+  TEST_EQUAL(cont, res, ());
+}
+
+template <typename T>
+void CollectionPrimitiveTest(T const & cont)
+{
+  ByteVector buffer;
+  MemWriter<decltype(buffer)> writer(buffer);
+  WriterSink<decltype(writer)> sink(writer);
+  coding_utils::WriteCollectionPrimitive(sink, cont);
+
+  MemReader reader(buffer.data(), buffer.size());
+  ReaderSource<decltype(reader)> src(reader);
+  T res;
+  coding_utils::ReadCollectionPrimitive(src, std::inserter(res, std::end(res)));
+  TEST_EQUAL(cont, res, ());
+}
+
+UNIT_TEST(Utils_DeltaEncodeDecode)
+{
+  {
+    std::vector<uint32_t> cont;
+    DeltaEncodeDecodelTest(cont);
+  }
+  {
+    std::list<uint32_t> cont{1, 2, 3, 4};
+    cont.sort();
+    DeltaEncodeDecodelTest(cont);
+  }
+  {
+    std::list<uint32_t> cont{6, 7, 30, 40};
+    cont.sort();
+    DeltaEncodeDecodelTest(cont, 6);
+  }
+  {
+    std::list<int32_t> cont{-1, -2, -3, -4};
+    cont.sort();
+    DeltaEncodeDecodelTest(cont);
+  }
+  {
+    std::vector<uint32_t> cont{1, 2, 3, 4, 32, 124};
+    std::sort(std::begin(cont), std::end(cont));
+    DeltaEncodeDecodelTest(cont, 1);
+  }
+  {
+    std::vector<int32_t> cont{-1, -2, -3, -4, 23, 67};
+    std::sort(std::begin(cont), std::end(cont));
+    DeltaEncodeDecodelTest(cont);
+  }
+  {
+    std::set<uint64_t> cont{1, 2, 3, 4, 999, 100124, 243};
+    DeltaEncodeDecodelTest(cont);
+  }
+  {
+    std::set<int64_t> cont{-1, -2, -3, -4};
+    DeltaEncodeDecodelTest(cont);
+  }
+}
+
+UNIT_TEST(Utils_CollectionPrimitive)
+{
+  {
+    std::list<uint8_t> const cont{1, 2, 3, 4};
+    CollectionPrimitiveTest(cont);
+  }
+  {
+    std::list<int8_t> const cont{-1, -2, -3, -4};
+    CollectionPrimitiveTest(cont);
+  }
+  {
+    std::vector<uint32_t> const cont{1, 2, 3, 4};
+    CollectionPrimitiveTest(cont);
+  }
+  {
+    std::vector<int32_t> const cont{-1, -2, -3, -4};
+    CollectionPrimitiveTest(cont);
+  }
+  {
+    std::set<uint64_t> const cont{1, 2, 3, 4};
+    CollectionPrimitiveTest(cont);
+  }
+  {
+    std::set<int64_t> const cont{-1, -2, -3, -4};
+    CollectionPrimitiveTest(cont);
+  }
+}
+}  // namespace