diff --git a/3party/jansson/myjansson.hpp b/3party/jansson/myjansson.hpp
index 5ceb98fc1b..ecba88eb9b 100644
--- a/3party/jansson/myjansson.hpp
+++ b/3party/jansson/myjansson.hpp
@@ -50,6 +50,7 @@ public:
   }
 
   json_t * get() const { return m_handle.get(); }
+  json_t * get_deep_copy() const { return json_deep_copy(get()); }
 };
 
 json_t * GetJSONObligatoryField(json_t * root, std::string const & field);
@@ -110,9 +111,9 @@ void ToJSONObject(json_t & root, std::string const & field, T const & value)
   json_object_set_new(&root, field.c_str(), ToJSON(value).release());
 }
 
-inline void ToJSONObject(json_t & root, std::string const & field, json_t & embedded)
+inline void ToJSONObject(json_t & parent, std::string const & field, json_t & child)
 {
-  json_object_set_new(&root, field.c_str(), &embedded);
+  json_object_set_new(&parent, field.c_str(), &child);
 }
 
 template <typename T>
diff --git a/indexer/index.cpp b/indexer/index.cpp
index 5f642f40f3..4ae66e8892 100644
--- a/indexer/index.cpp
+++ b/indexer/index.cpp
@@ -15,6 +15,7 @@ using platform::LocalCountryFile;
 //////////////////////////////////////////////////////////////////////////////////
 // MwmValue implementation
 //////////////////////////////////////////////////////////////////////////////////
+using namespace std;
 
 MwmValue::MwmValue(LocalCountryFile const & localFile)
   : m_cont(platform::GetCountryReader(localFile, MapOptions::Map)), m_file(localFile)
@@ -112,6 +113,29 @@ bool Index::FeaturesLoaderGuard::IsWorld() const
   return m_handle.GetValue<MwmValue>()->GetHeader().GetType() == feature::DataHeader::world;
 }
 
+unique_ptr<FeatureType> Index::FeaturesLoaderGuard::GetOriginalFeatureByIndex(uint32_t index) const
+{
+  auto feature = make_unique<FeatureType>();
+  if (!GetOriginalFeatureByIndex(index, *feature))
+    return unique_ptr<FeatureType>();
+
+  return feature;
+}
+
+unique_ptr<FeatureType> Index::FeaturesLoaderGuard::GetOriginalOrEditedFeatureByIndex(uint32_t index) const
+{
+  auto feature = make_unique<FeatureType>();
+  if (!m_handle.IsAlive())
+    return feature;
+
+  MwmId const & id = m_handle.GetId();
+  ASSERT_NOT_EQUAL(m_editor.GetFeatureStatus(id, index), osm::Editor::FeatureStatus::Created, ());
+  if (!GetFeatureByIndex(index, *feature))
+    return unique_ptr<FeatureType>();
+
+  return feature;
+}
+
 bool Index::FeaturesLoaderGuard::GetFeatureByIndex(uint32_t index, FeatureType & ft) const
 {
   if (!m_handle.IsAlive())
diff --git a/indexer/index.hpp b/indexer/index.hpp
index 93b22b7aa6..0f1f55e685 100644
--- a/indexer/index.hpp
+++ b/indexer/index.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include "indexer/cell_id.hpp"
 #include "indexer/data_factory.hpp"
+#include "indexer/feature.hpp"
 #include "indexer/feature_covering.hpp"
 #include "indexer/features_offsets_table.hpp"
 #include "indexer/features_vector.hpp"
@@ -15,11 +16,11 @@
 
 #include "base/macros.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/limits.hpp"
-#include "std/utility.hpp"
-#include "std/vector.hpp"
-#include "std/weak_ptr.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <utility>
+#include <vector>
 
 class MwmInfoEx : public MwmInfo
 {
@@ -35,7 +36,7 @@ private:
   // only in MwmValue::SetTable() method, which, in turn, is called
   // only in the MwmSet critical section, protected by a lock.  So,
   // there's an implicit synchronization on this field.
-  weak_ptr<feature::FeaturesOffsetsTable> m_table;
+  std::weak_ptr<feature::FeaturesOffsetsTable> m_table;
 };
 
 class MwmValue : public MwmSet::MwmValueBase
@@ -45,7 +46,7 @@ public:
   IndexFactory m_factory;
   platform::LocalCountryFile const m_file;
 
-  shared_ptr<feature::FeaturesOffsetsTable> m_table;
+  std::shared_ptr<feature::FeaturesOffsetsTable> m_table;
 
   explicit MwmValue(platform::LocalCountryFile const & localFile);
   void SetTable(MwmInfoEx & info);
@@ -53,7 +54,10 @@ public:
   inline feature::DataHeader const & GetHeader() const { return m_factory.GetHeader(); }
   inline feature::RegionData const & GetRegionData() const { return m_factory.GetRegionData(); }
   inline version::MwmVersion const & GetMwmVersion() const { return m_factory.GetMwmVersion(); }
-  inline string const & GetCountryFileName() const { return m_file.GetCountryFile().GetName(); }
+  inline std::string const & GetCountryFileName() const
+  {
+    return m_file.GetCountryFile().GetName();
+  }
 
   inline bool HasSearchIndex() { return m_cont.IsExist(SEARCH_INDEX_FILE_TAG); }
   inline bool HasGeometryIndex() { return m_cont.IsExist(INDEX_FILE_TAG); }
@@ -64,14 +68,14 @@ class Index : public MwmSet
 protected:
   /// MwmSet overrides:
   //@{
-  unique_ptr<MwmInfo> CreateInfo(platform::LocalCountryFile const & localFile) const override;
+  std::unique_ptr<MwmInfo> CreateInfo(platform::LocalCountryFile const & localFile) const override;
 
-  unique_ptr<MwmValueBase> CreateValue(MwmInfo & info) const override;
+  std::unique_ptr<MwmValueBase> CreateValue(MwmInfo & info) const override;
   //@}
 
 public:
   /// Registers a new map.
-  pair<MwmId, RegResult> RegisterMap(platform::LocalCountryFile const & localFile);
+  std::pair<MwmId, RegResult> RegisterMap(platform::LocalCountryFile const & localFile);
 
   /// Deregisters a map from internal records.
   ///
@@ -230,7 +234,7 @@ public:
 
   // "features" must be sorted using FeatureID::operator< as predicate.
   template <typename F>
-  void ReadFeatures(F && f, vector<FeatureID> const & features) const
+  void ReadFeatures(F && f, std::vector<FeatureID> const & features) const
   {
     auto fidIter = features.begin();
     auto const endIter = features.end();
@@ -279,9 +283,12 @@ public:
     FeaturesLoaderGuard(Index const & index, MwmId const & id);
 
     inline MwmSet::MwmId const & GetId() const { return m_handle.GetId(); }
-    string GetCountryFileName() const;
+    std::string GetCountryFileName() const;
     bool IsWorld() const;
 
+    std::unique_ptr<FeatureType> GetOriginalFeatureByIndex(uint32_t index) const;
+    std::unique_ptr<FeatureType> GetOriginalOrEditedFeatureByIndex(uint32_t index) const;
+
     /// Everyone, except Editor core, should use this method.
     WARN_UNUSED_RESULT bool GetFeatureByIndex(uint32_t index, FeatureType & ft) const;
 
@@ -290,9 +297,10 @@ public:
 
     size_t GetNumFeatures() const;
 
+
   private:
     MwmHandle m_handle;
-    unique_ptr<FeaturesVector> m_vector;
+    std::unique_ptr<FeaturesVector> m_vector;
     osm::Editor & m_editor = osm::Editor::Instance();
   };
 
@@ -314,7 +322,7 @@ private:
   void ForEachInIntervals(F && f, covering::CoveringMode mode, m2::RectD const & rect,
                           int scale) const
   {
-    vector<shared_ptr<MwmInfo>> mwms;
+    std::vector<std::shared_ptr<MwmInfo>> mwms;
     GetMwmsInfo(mwms);
 
     covering::CoveringGetter cov(rect, mode);
diff --git a/search/editor_delegate.cpp b/search/editor_delegate.cpp
index b34cde6cde..95e41c963d 100644
--- a/search/editor_delegate.cpp
+++ b/search/editor_delegate.cpp
@@ -17,11 +17,11 @@ MwmSet::MwmId EditorDelegate::GetMwmIdByMapName(string const & name) const
 
 unique_ptr<FeatureType> EditorDelegate::GetOriginalFeature(FeatureID const & fid) const
 {
-  auto feature = make_unique<FeatureType>();
-  Index::FeaturesLoaderGuard const guard(m_index, fid.m_mwmId);
-  if (!guard.GetOriginalFeatureByIndex(fid.m_index, *feature))
-    return unique_ptr<FeatureType>();
-  feature->ParseEverything();
+  Index::FeaturesLoaderGuard guard(m_index, fid.m_mwmId);
+  auto feature = guard.GetOriginalFeatureByIndex(fid.m_index);
+  if (feature)
+    feature->ParseEverything();
+
   return feature;
 }
 
diff --git a/ugc/api.cpp b/ugc/api.cpp
index f5bf0b3b72..b709b344f8 100644
--- a/ugc/api.cpp
+++ b/ugc/api.cpp
@@ -9,7 +9,7 @@ using namespace ugc;
 
 namespace ugc
 {
-Api::Api(Index const & index) : m_storage(index) {}
+Api::Api(Index const & index) : m_storage(index), m_loader(index) {}
 
 void Api::GetUGC(FeatureID const & id, UGCCallback callback)
 {
diff --git a/ugc/serdes_json.hpp b/ugc/serdes_json.hpp
index 6fe587f352..613e1dd1b1 100644
--- a/ugc/serdes_json.hpp
+++ b/ugc/serdes_json.hpp
@@ -27,6 +27,8 @@ public:
   void operator()(uint8_t const d, char const * name = nullptr) { ToJSONObject(*m_json, name, d); }
   void operator()(uint32_t const d, char const * name = nullptr) { ToJSONObject(*m_json, name, d); }
   void operator()(uint64_t const d, char const * name = nullptr) { ToJSONObject(*m_json, name, d); }
+  void operator()(int64_t const d, char const * name = nullptr) { ToJSONObject(*m_json, name, d); }
+  void operator()(double const d, char const * name = nullptr) { ToJSONObject(*m_json, name, d); }
   void operator()(std::string const & s, char const * name = nullptr)
   {
     ToJSONObject(*m_json, name, s);
@@ -69,8 +71,7 @@ public:
   void VisitRating(float const f, char const * name = nullptr)
   {
     CHECK_GREATER_OR_EQUAL(f, 0.0, ());
-    auto const d = static_cast<double>(f);
-    ToJSONObject(*m_json, name, d);
+    (*this)(static_cast<double>(f), name);
   }
 
   template <typename T>
@@ -84,6 +85,12 @@ public:
     ToJSONObject(*m_json, name, StringUtf8Multilang::GetLangByCode(index));
   }
 
+  void VisitPoint(m2::PointD const & pt, char const * x = nullptr, char const * y = nullptr)
+  {
+    (*this)(pt.x, x);
+    (*this)(pt.y, y);
+  }
+
 private:
   template <typename Fn>
   void NewScopeWith(my::JSONPtr json_object, char const * name, Fn && fn)
@@ -137,6 +144,8 @@ public:
   void operator()(uint8_t & d, char const * name = nullptr) { FromJSONObject(m_json, name, d); }
   void operator()(uint32_t & d, char const * name = nullptr) { FromJSONObject(m_json, name, d); }
   void operator()(uint64_t & d, char const * name = nullptr) { FromJSONObject(m_json, name, d); }
+  void operator()(int64_t & d, char const * name = nullptr) { FromJSONObject(m_json, name, d); }
+  void operator()(double & d, char const * name = nullptr) { FromJSONObject(m_json, name, d); }
   void operator()(std::string & s, char const * name = nullptr) { FromJSONObject(m_json, name, s); }
   void operator()(TranslationKey & key, char const * name = nullptr)
   {
@@ -205,6 +214,12 @@ public:
     index = StringUtf8Multilang::GetLangIndex(lang);
   }
 
+  void VisitPoint(m2::PointD & pt, char const * x = nullptr, char const * y = nullptr)
+  {
+    FromJSONObject(m_json, x, pt.x);
+    FromJSONObject(m_json, y, pt.y);
+  }
+
 private:
   json_t * SaveContext(char const * name = nullptr)
   {
diff --git a/ugc/storage.cpp b/ugc/storage.cpp
index 0f807594f2..fcdd25c0dd 100644
--- a/ugc/storage.cpp
+++ b/ugc/storage.cpp
@@ -2,13 +2,14 @@
 #include "ugc/serdes.hpp"
 #include "ugc/serdes_json.hpp"
 
+#include "indexer/feature_decl.hpp"
+#include "indexer/index.hpp"
+
+#include "coding/file_name_utils.hpp"
 #include "coding/file_reader.hpp"
 #include "coding/file_writer.hpp"
 #include "coding/internal/file_data.hpp"
 
-#include "indexer/feature_decl.hpp"
-#include "indexer/index.hpp"
-
 #include "platform/platform.hpp"
 
 #include <algorithm>
@@ -19,95 +20,31 @@
 namespace ugc
 {
 using namespace std;
+
 namespace
 {
 string const kIndexFileName = "index.json";
 string const kUGCUpdateFileName = "ugc.update.bin";
 string const kTmpFileExtension = ".tmp";
 
-char const kOffsetKey[] = "offset";
-char const kXKey[] = "x";
-char const kYKey[] = "y";
-char const kTypeKey[] = "type";
-char const kIsDeletedKey[] = "is_deleted";
-char const kIsSynchronizedKey[] = "is_synchronized";
-char const kMwmNameKey[] = "mwm_name";
-char const kDataVersionKey[] = "data_version";
-char const kFeatureIdKey[] = "feature_id";
-char const kFeatureKey[] = "feature";
+using Sink = MemWriter<vector<char>>;
 
-string GetUGCFilePath()
-{
-  return GetPlatform().WritableDir() + kUGCUpdateFileName;
-}
+string GetUGCFilePath() { return my::JoinPath(GetPlatform().WritableDir(), kUGCUpdateFileName); }
 
-string GetIndexFilePath()
-{
-  return GetPlatform().WritableDir() + kIndexFileName;
-}
+string GetIndexFilePath() { return my::JoinPath(GetPlatform().WritableDir(), kIndexFileName); }
 
 bool GetUGCFileSize(uint64_t & size)
 {
   return GetPlatform().GetFileSizeByName(kUGCUpdateFileName, size);
 }
 
-void DeserializeUGCIndex(string const & jsonData, vector<Storage::UGCIndex> & res, size_t & numberOfDeleted)
+void DeserializeUGCIndex(string const & jsonData, vector<Storage::UGCIndex> & res)
 {
   if (jsonData.empty())
     return;
 
-  my::Json root(jsonData.c_str());
-  if (!root.get() || !json_is_array(root.get()))
-    return;
-
-  size_t const size = json_array_size(root.get());
-  if (size == 0)
-    return;
-
-  for (size_t i = 0; i < size; ++i)
-  {
-    auto node = json_array_get(root.get(), i);
-    if (!node)
-      return;
-
-    Storage::UGCIndex index;
-    double x, y;
-    FromJSONObject(node, kXKey, x);
-    FromJSONObject(node, kYKey, y);
-    index.m_mercator = {x, y};
-
-    uint32_t type;
-    FromJSONObject(node, kTypeKey, type);
-    index.m_type = type;
-
-    uint64_t offset;
-    FromJSONObject(node, kOffsetKey, offset);
-    index.m_offset = offset;
-
-    bool isDeleted;
-    FromJSONObject(node, kIsDeletedKey, isDeleted);
-    index.m_isDeleted = isDeleted;
-    if (isDeleted)
-      numberOfDeleted++;
-
-    bool isSynchronized;
-    FromJSONObject(node, kIsSynchronizedKey, isSynchronized);
-    index.m_isSynchronized = isDeleted;
-
-    string mwmName;
-    FromJSONObject(node, kMwmNameKey, mwmName);
-    index.m_mwmName = mwmName;
-
-    string mwmVersion;
-    FromJSONObject(node, kDataVersionKey, mwmVersion);
-    index.m_dataVersion = mwmName;
-
-    uint32_t featureId;
-    FromJSONObject(node, kFeatureIdKey, featureId);
-    index.m_featureId = featureId;
-
-    res.emplace_back(move(index));
-  }
+  DeserializerJsonV0 des(jsonData);
+  des(res);
 }
 
 string SerializeUGCIndex(vector<Storage::UGCIndex> const & indexes)
@@ -116,50 +53,24 @@ string SerializeUGCIndex(vector<Storage::UGCIndex> const & indexes)
     return string();
 
   auto array = my::NewJSONArray();
-  for (auto const & i : indexes)
+  for (auto const & index : indexes)
   {
-    auto node = my::NewJSONObject();
-    auto const & mercator = i.m_mercator;
-    ToJSONObject(*node, kXKey, mercator.x);
-    ToJSONObject(*node, kYKey, mercator.y);
-    ToJSONObject(*node, kTypeKey, i.m_type);
-    ToJSONObject(*node, kOffsetKey, i.m_offset);
-    ToJSONObject(*node, kIsDeletedKey, i.m_isDeleted);
-    ToJSONObject(*node, kIsSynchronizedKey, i.m_isSynchronized);
-    ToJSONObject(*node, kMwmNameKey, i.m_mwmName);
-    ToJSONObject(*node, kDataVersionKey, i.m_dataVersion);
-    ToJSONObject(*node, kFeatureIdKey, i.m_featureId);
-    json_array_append_new(array.get(), node.release());
+    vector<char> data;
+    {
+      Sink sink(data);
+      SerializerJson<Sink> ser(sink);
+      ser(index);
+    }
+    my::Json node(data.data());
+    json_array_append_new(array.get(), node.get_deep_copy());
   }
 
   unique_ptr<char, JSONFreeDeleter> buffer(json_dumps(array.get(), JSON_COMPACT | JSON_ENSURE_ASCII));
   return string(buffer.get());
 }
-
-void SerializeUGCUpdate(json_t * node, UGCUpdate const & update, Storage::UGCIndex const & index)
-{
-  vector<char> data;
-  using Sink = MemWriter<vector<char>>;
-  Sink sink(data);
-  SerializerJson<Sink> ser(sink);
-  ser(update);
-
-  my::Json serializedUgc(data.data());
-  node = serializedUgc.get();
-  auto embeddedNode = my::NewJSONObject();
-  ToJSONObject(*embeddedNode, kDataVersionKey, index.m_dataVersion);
-  ToJSONObject(*embeddedNode, kMwmNameKey, index.m_mwmName);
-  ToJSONObject(*embeddedNode, kFeatureIdKey, index.m_featureId);
-  ToJSONObject(*node, kFeatureKey, *embeddedNode);
-  embeddedNode.release();
-}
 }  // namespace
 
-Storage::Storage(Index const & index)
-  : m_index(index)
-{
-  Load();
-}
+Storage::Storage(Index const & index) : m_index(index) { Load(); }
 
 UGCUpdate Storage::GetUGCUpdate(FeatureID const & id) const
 {
@@ -167,40 +78,34 @@ UGCUpdate Storage::GetUGCUpdate(FeatureID const & id) const
   if (m_UGCIndexes.empty())
     return {};
 
-  auto const feature = GetOriginalFeature(id);
-  CHECK(feature, ());
+  auto const feature = GetFeature(id);
+  CHECK_EQUAL(feature->GetFeatureType(), feature::EGeomType::GEOM_POINT, ());
   auto const & mercator = feature->GetCenter();
   feature::TypesHolder th(*feature);
   th.SortBySpec();
   auto const type = th.GetBestType();
 
-  auto const index = find_if(m_UGCIndexes.begin(), m_UGCIndexes.end(), [type, &mercator](UGCIndex const & index) -> bool
-  {
-    return type == index.m_type && mercator == index.m_mercator && !index.m_isDeleted;
-  });
+  auto const index = find_if(
+      m_UGCIndexes.begin(), m_UGCIndexes.end(), [type, &mercator](UGCIndex const & index) -> bool {
+        return type == index.m_type && mercator == index.m_mercator && !index.m_deleted;
+      });
 
   if (index == m_UGCIndexes.end())
     return {};
 
   auto const offset = index->m_offset;
-  auto const nextIndex = index + 1;
-  uint64_t nextOffset;
-  if (nextIndex == m_UGCIndexes.end())
-    CHECK(GetPlatform().GetFileSizeByName(kUGCUpdateFileName, nextOffset), ());
-  else
-    nextOffset = nextIndex->m_offset;
-
-  auto const size = nextOffset - offset;
+  auto const size = UGCSizeAtIndex(distance(m_UGCIndexes.begin(), index));
   vector<uint8_t> buf;
+  buf.resize(size);
   auto const ugcFilePath = GetUGCFilePath();
   try
   {
     FileReader r(ugcFilePath);
     r.Read(offset, buf.data(), size);
   }
-  catch (RootException const & exception)
+  catch (FileReader::Exception const & exception)
   {
-    LOG(LWARNING, ("Exception while reading file:", ugcFilePath));
+    LOG(LERROR, ("Exception while reading file:", ugcFilePath, "reason:", exception.Msg()));
     return {};
   }
 
@@ -214,48 +119,47 @@ UGCUpdate Storage::GetUGCUpdate(FeatureID const & id) const
 void Storage::SetUGCUpdate(FeatureID const & id, UGCUpdate const & ugc)
 {
   ASSERT_THREAD_CHECKER(m_threadChecker, ());
-  auto const feature = GetOriginalFeature(id);
-  CHECK(feature, ());
-
+  auto const feature = GetFeature(id);
+  CHECK_EQUAL(feature->GetFeatureType(), feature::EGeomType::GEOM_POINT, ());
   auto const & mercator = feature->GetCenter();
   feature::TypesHolder th(*feature);
   th.SortBySpec();
   auto const type = th.GetBestType();
   for (auto & index : m_UGCIndexes)
   {
-    if (type == index.m_type && mercator == index.m_mercator && !index.m_isDeleted)
+    if (type == index.m_type && mercator == index.m_mercator && !index.m_deleted)
     {
-      index.m_isDeleted = true;
+      index.m_deleted = true;
       m_numberOfDeleted++;
       break;
     }
   }
   // TODO: Call Defragmentation().
 
-  auto const ugcFilePath = GetUGCFilePath();
-  try
-  {
-    FileWriter w(ugcFilePath);
-    Serialize(w, ugc);
-  }
-  catch (RootException const & exception)
-  {
-    LOG(LWARNING, ("Exception while writing file:", ugcFilePath));
-    return;
-  }
-
   UGCIndex index;
-  index.m_mercator = mercator;
   uint64_t offset;
-  if (GetUGCFileSize(offset))
+  if (!GetUGCFileSize(offset))
     offset = 0;
 
+  index.m_mercator = mercator;
   index.m_type = type;
   index.m_mwmName = id.GetMwmName();
   index.m_dataVersion = id.GetMwmVersion();
   index.m_featureId = id.m_index;
   index.m_offset = offset;
-  m_UGCIndexes.emplace_back(move(index));
+
+  auto const ugcFilePath = GetUGCFilePath();
+  try
+  {
+    FileWriter w(ugcFilePath, FileWriter::Op::OP_APPEND);
+    Serialize(w, ugc);
+    m_UGCIndexes.emplace_back(move(index));
+  }
+  catch (FileWriter::Exception const & exception)
+  {
+    LOG(LERROR, ("Exception while writing file:", ugcFilePath, "reason:", exception.Msg()));
+    return;
+  }
 }
 
 void Storage::Load()
@@ -268,21 +172,26 @@ void Storage::Load()
     FileReader r(indexFilePath);
     r.ReadAsString(data);
   }
-  catch (RootException const & exception)
+  catch (FileReader::Exception const & exception)
   {
-    LOG(LWARNING, ("Exception while reading file:", indexFilePath));
+    LOG(LWARNING, ("Exception while reading file:", indexFilePath, "reason:", exception.Msg()));
     return;
   }
 
-  DeserializeUGCIndex(data, m_UGCIndexes, m_numberOfDeleted);
-  sort(m_UGCIndexes.begin(), m_UGCIndexes.end(), [](UGCIndex const & lhs, UGCIndex const & rhs) -> bool {
-    return lhs.m_offset < rhs.m_offset;
-  });
+  DeserializeUGCIndex(data, m_UGCIndexes);
+  for (auto const & i : m_UGCIndexes)
+  {
+    if (i.m_deleted)
+      ++m_numberOfDeleted;
+  }
 }
 
 void Storage::SaveIndex() const
 {
   ASSERT_THREAD_CHECKER(m_threadChecker, ());
+  if (m_UGCIndexes.empty())
+    return;
+
   auto const jsonData = SerializeUGCIndex(m_UGCIndexes);
   auto const indexFilePath = GetIndexFilePath();
   try
@@ -290,9 +199,9 @@ void Storage::SaveIndex() const
     FileWriter w(indexFilePath);
     w.Write(jsonData.c_str(), jsonData.length());
   }
-  catch (RootException const & exception)
+  catch (FileWriter::Exception const & exception)
   {
-    LOG(LWARNING, ("Exception while writing file:", indexFilePath));
+    LOG(LERROR, ("Exception while writing file:", indexFilePath, "reason:", exception.Msg()));
   }
 }
 
@@ -306,46 +215,45 @@ void Storage::Defragmentation()
   auto const ugcFilePath = GetUGCFilePath();
   auto const tmpUGCFilePath = ugcFilePath + kTmpFileExtension;
   FileReader r(ugcFilePath);
+
   vector<uint8_t> buf;
-  for (size_t i = 0; i < indexesSize; ++i)
-  {
-    auto const & index = m_UGCIndexes[i];
-    if (index.m_isDeleted)
-      continue;
-
-    auto const offset = index.m_offset;
-    uint64_t nextOffset;
-    if (i == indexesSize - 1)
-      GetUGCFileSize(nextOffset);
-    else
-      nextOffset = m_UGCIndexes[i + 1].m_offset;
-
-    auto const bufSize = nextOffset - offset;
-    try
-    {
-      r.Read(offset, buf.data(), bufSize);
-    }
-    catch (RootException const & excpetion)
-    {
-      LOG(LWARNING, ("Exception while reading file:", ugcFilePath));
-      return;
-    }
-  }
+  uint64_t maxBufSize;
+  CHECK(GetUGCFileSize(maxBufSize), ());
+  buf.resize(maxBufSize);
+  uint64_t actualBufSize = 0;
 
   try
   {
+    for (size_t i = 0; i < indexesSize; ++i)
+    {
+      CHECK_LESS_OR_EQUAL(actualBufSize, maxBufSize, ());
+      auto & index = m_UGCIndexes[i];
+      if (index.m_deleted)
+        continue;
+
+      auto const offset = index.m_offset;
+      auto const size = UGCSizeAtIndex(i);
+      r.Read(offset, buf.data() + actualBufSize, size);
+      index.m_offset = actualBufSize;
+      actualBufSize += size;
+    }
+
     FileWriter w(tmpUGCFilePath);
-    w.Write(buf.data(), buf.size());
+    w.Write(buf.data(), actualBufSize);
   }
-  catch (RootException const & exception)
+  catch (FileReader::Exception const & exception)
   {
-    LOG(LWARNING, ("Exception while reading file:", tmpUGCFilePath));
+    LOG(LERROR, ("Exception while reading file:", ugcFilePath, "reason:", exception.Msg()));
+    return;
+  }
+  catch (FileWriter::Exception const & exception)
+  {
+    LOG(LERROR, ("Exception while writing file:", tmpUGCFilePath, "reason:", exception.Msg()));
     return;
   }
 
-  m_UGCIndexes.erase(remove_if(m_UGCIndexes.begin(), m_UGCIndexes.end(), [](UGCIndex const & i) -> bool {
-    return i.m_isDeleted;
-  }));
+  m_UGCIndexes.erase(remove_if(m_UGCIndexes.begin(), m_UGCIndexes.end(),
+                               [](UGCIndex const & i) -> bool { return i.m_deleted; }), m_UGCIndexes.end());
 
   CHECK(my::DeleteFileX(ugcFilePath), ());
   CHECK(my::RenameFileX(tmpUGCFilePath, ugcFilePath), ());
@@ -368,24 +276,19 @@ string Storage::GetUGCToSend() const
   {
     buf.clear();
     auto const & index = m_UGCIndexes[i];
-    if (index.m_isSynchronized)
+    if (index.m_synchronized)
       continue;
 
     auto const offset = index.m_offset;
-    uint64_t nextOffset;
-    if (i == indexesSize - 1)
-      CHECK(GetUGCFileSize(nextOffset), ());
-    else
-      nextOffset = m_UGCIndexes[i + 1].m_offset;
-
-    auto const bufSize = nextOffset - offset;
+    auto const bufSize = UGCSizeAtIndex(i);
+    buf.resize(bufSize);
     try
     {
       r.Read(offset, buf.data(), bufSize);
     }
-    catch (RootException const & excpetion)
+    catch (FileReader::Exception const & exception)
     {
-      LOG(LWARNING, ("Exception while reading file:", ugcFilePath));
+      LOG(LERROR, ("Exception while reading file:", ugcFilePath, "reason:", exception.Msg()));
       return string();
     }
 
@@ -394,12 +297,29 @@ string Storage::GetUGCToSend() const
     UGCUpdate update;
     Deserialize(source, update);
 
-    auto node = my::NewJSONObject();
-    SerializeUGCUpdate(node.get(), update, index);
-    json_array_append_new(array.get(), node.release());
+    vector<char> data;
+    {
+      Sink sink(data);
+      SerializerJson<Sink> ser(sink);
+      ser(update);
+    }
+
+    my::Json serializedUgc(data.data());
+    auto embeddedNode = my::NewJSONObject();
+    ToJSONObject(*embeddedNode.get(), "data_version", index.m_dataVersion);
+    ToJSONObject(*embeddedNode.get(), "mwm_name", index.m_mwmName);
+    ToJSONObject(*embeddedNode.get(), "feature_id", index.m_featureId);
+    ToJSONObject(*serializedUgc.get(), "feature", *embeddedNode.release());
+    json_array_append_new(array.get(), serializedUgc.get_deep_copy());
   }
 
-  unique_ptr<char, JSONFreeDeleter> buffer(json_dumps(array.get(), JSON_COMPACT | JSON_ENSURE_ASCII));
+  if (json_array_size(array.get()) == 0)
+    return string();
+
+  auto reviewsNode = my::NewJSONObject();
+  ToJSONObject(*reviewsNode.get(), "reviews", *array.release());
+
+  unique_ptr<char, JSONFreeDeleter> buffer(json_dumps(reviewsNode.get(), JSON_COMPACT | JSON_ENSURE_ASCII));
   return string(buffer.get());
 }
 
@@ -410,25 +330,38 @@ void Storage::MarkAllAsSynchronized()
     return;
 
   for (auto & index : m_UGCIndexes)
-    index.m_isSynchronized = true;
+    index.m_synchronized = true;
 
   auto const indexPath = GetIndexFilePath();
   my::DeleteFileX(indexPath);
   SaveIndex();
 }
 
-unique_ptr<FeatureType> Storage::GetOriginalFeature(FeatureID const & id) const
+uint64_t Storage::UGCSizeAtIndex(size_t const indexPosition) const
+{
+  ASSERT_THREAD_CHECKER(m_threadChecker, ());
+  CHECK(!m_UGCIndexes.empty(), ());
+  auto const indexesSize = m_UGCIndexes.size();
+  CHECK_LESS(indexPosition, indexesSize, ());
+  auto const indexOffset = m_UGCIndexes[indexPosition].m_offset;
+  uint64_t nextOffset;
+  if (indexPosition == indexesSize - 1)
+    CHECK(GetUGCFileSize(nextOffset), ());
+  else
+    nextOffset = m_UGCIndexes[indexPosition + 1].m_offset;
+
+  CHECK_GREATER(nextOffset, indexOffset, ());
+  return nextOffset - indexOffset;
+}
+
+unique_ptr<FeatureType> Storage::GetFeature(FeatureID const & id) const
 {
   ASSERT_THREAD_CHECKER(m_threadChecker, ());
   CHECK(id.IsValid(), ());
-
-  auto feature = make_unique<FeatureType>();
-  Index::FeaturesLoaderGuard const guard(m_index, id.m_mwmId);
-  if (!guard.GetOriginalFeatureByIndex(id.m_index, *feature))
-    return unique_ptr<FeatureType>();
-
-  feature->ParseEverything();
+  Index::FeaturesLoaderGuard guard(m_index, id.m_mwmId);
+  auto feature = guard.GetOriginalOrEditedFeatureByIndex(id.m_index);
+  feature->ParseGeometry(0);
+  CHECK(feature, ());
   return feature;
 }
 }  // namespace ugc
-
diff --git a/ugc/storage.hpp b/ugc/storage.hpp
index 45b6ba7b2d..c8f9cb6a67 100644
--- a/ugc/storage.hpp
+++ b/ugc/storage.hpp
@@ -5,6 +5,7 @@
 #include "geometry/point2d.hpp"
 
 #include "base/thread_checker.hpp"
+#include "base/visitor.hpp"
 
 #include <memory>
 #include <string>
@@ -21,30 +22,39 @@ class Storage
 public:
   struct UGCIndex
   {
+    DECLARE_VISITOR(visitor.VisitPoint(m_mercator, "x", "y"), visitor(m_type, "type"),
+                    visitor(m_offset, "offset"), visitor(m_deleted, "deleted"),
+                    visitor(m_synchronized, "synchronized"), visitor(m_mwmName, "mwm_name"),
+                    visitor(m_dataVersion, "data_version"), visitor(m_featureId, "feature_id"))
+
     m2::PointD m_mercator{};
-    uint32_t m_type{};
-    uint64_t m_offset{};
-    bool m_isDeleted = false;
-    bool m_isSynchronized = false;
+    uint32_t m_type = 0;
+    uint64_t m_offset = 0;
+    bool m_deleted = false;
+    bool m_synchronized = false;
     std::string m_mwmName;
-    std::string m_dataVersion;
-    uint32_t m_featureId{};
+    int64_t m_dataVersion;
+    uint32_t m_featureId = 0;
   };
 
   explicit Storage(Index const & index);
 
   UGCUpdate GetUGCUpdate(FeatureID const & id) const;
   void SetUGCUpdate(FeatureID const & id, UGCUpdate const & ugc);
-
   void SaveIndex() const;
-  void Load();
-  void Defragmentation();
   std::string GetUGCToSend() const;
   void MarkAllAsSynchronized();
+  void Defragmentation();
 
-  std::unique_ptr<FeatureType> GetOriginalFeature(FeatureID const & id) const;
+  /// Testing
+  std::vector<UGCIndex> const & GetIndexesForTesting() const { return m_UGCIndexes; }
+  size_t GetNumberOfDeletedForTesting() const { return m_numberOfDeleted; }
 
 private:
+  void Load();
+  uint64_t UGCSizeAtIndex(size_t const indexPosition) const;
+  std::unique_ptr<FeatureType> GetFeature(FeatureID const & id) const;
+
   Index const & m_index;
   std::vector<UGCIndex> m_UGCIndexes;
   size_t m_numberOfDeleted = 0;
diff --git a/ugc/types.hpp b/ugc/types.hpp
index 2f8a398504..dd00f92000 100644
--- a/ugc/types.hpp
+++ b/ugc/types.hpp
@@ -241,7 +241,7 @@ struct UGCUpdate
   {
   }
 
-  DECLARE_VISITOR(visitor(m_ratings, "ratings"), visitor(m_text, "text"), visitor(m_time, "time"))
+  DECLARE_VISITOR(visitor(m_ratings, "ratings"), visitor(m_text, "text"), visitor(m_time, "date"))
 
   bool operator==(UGCUpdate const & rhs) const
   {