diff --git a/src/interfaces/report_factory.hpp b/src/interfaces/report_factory.hpp
index 6a255a4..e1f9f2a 100644
--- a/src/interfaces/report_factory.hpp
+++ b/src/interfaces/report_factory.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "interfaces/json_storage.hpp"
+#include "interfaces/metric.hpp"
 #include "interfaces/report.hpp"
 #include "interfaces/report_manager.hpp"
 #include "types/report_action.hpp"
@@ -25,6 +26,13 @@
     virtual std::vector<LabeledMetricParameters>
         convertMetricParams(boost::asio::yield_context& yield,
                             const ReadingParameters& metricParams) const = 0;
+    virtual std::vector<LabeledMetricParameters>
+        convertMetricParams(const ReadingParameters& metricParams) const = 0;
+
+    virtual void
+        updateMetrics(std::vector<std::shared_ptr<interfaces::Metric>>& metrics,
+                      bool enabled,
+                      const ReadingParameters& metricParams) const = 0;
 
     virtual std::unique_ptr<interfaces::Report>
         make(const std::string& id, const std::string& name,
diff --git a/src/report.cpp b/src/report.cpp
index 18ca9c1..12d88c7 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -24,10 +24,11 @@
                interfaces::ReportManager& reportManager,
                interfaces::JsonStorage& reportStorageIn,
                std::vector<std::shared_ptr<interfaces::Metric>> metricsIn,
+               const interfaces::ReportFactory& reportFactory,
                const bool enabledIn, std::unique_ptr<interfaces::Clock> clock) :
     id(reportId),
     name(reportName), reportingType(reportingTypeIn), interval(intervalIn),
-    reportActions(std::move(reportActionsIn)),
+    reportActions(reportActionsIn.begin(), reportActionsIn.end()),
     sensorCount(getSensorCount(metricsIn)),
     appendLimit(deduceAppendLimit(appendLimitIn)),
     reportUpdates(reportUpdatesIn),
@@ -51,6 +52,8 @@
                 std::get<1>(sensorData.front()));
         });
 
+    reportActions.insert(ReportAction::logToMetricReportsCollection);
+
     deleteIface = objServer->add_unique_interface(
         getPath(), deleteIfaceName,
         [this, &ioc, &reportManager](auto& dbusIface) {
@@ -66,7 +69,7 @@
         });
 
     persistency = storeConfiguration();
-    reportIface = makeReportInterface();
+    reportIface = makeReportInterface(reportFactory);
 
     if (reportingType == ReportingType::periodic)
     {
@@ -153,22 +156,28 @@
     }
 }
 
+void Report::setReadingBuffer(const ReportUpdates newReportUpdates)
+{
+    if (reportingType != ReportingType::onRequest &&
+        (reportUpdates == ReportUpdates::overwrite ||
+         newReportUpdates == ReportUpdates::overwrite))
+    {
+        readingsBuffer.clearAndResize(
+            deduceBufferSize(newReportUpdates, reportingType));
+    }
+}
+
 void Report::setReportUpdates(const ReportUpdates newReportUpdates)
 {
     if (reportUpdates != newReportUpdates)
     {
-        if (reportingType != ReportingType::onRequest &&
-            (reportUpdates == ReportUpdates::overwrite ||
-             newReportUpdates == ReportUpdates::overwrite))
-        {
-            readingsBuffer.clearAndResize(
-                deduceBufferSize(newReportUpdates, reportingType));
-        }
+        setReadingBuffer(newReportUpdates);
         reportUpdates = newReportUpdates;
     }
 }
 
-std::unique_ptr<sdbusplus::asio::dbus_interface> Report::makeReportInterface()
+std::unique_ptr<sdbusplus::asio::dbus_interface>
+    Report::makeReportInterface(const interfaces::ReportFactory& reportFactory)
 {
     auto dbusIface =
         objServer->add_unique_interface(getPath(), reportIfaceName);
@@ -241,29 +250,69 @@
         },
         [this](const auto&) { return persistency; });
 
-    auto readingsFlag = sdbusplus::vtable::property_::none;
-    if (utils::contains(reportActions, ReportAction::emitsReadingsUpdate))
-    {
-        readingsFlag = sdbusplus::vtable::property_::emits_change;
-    }
-    dbusIface->register_property_r("Readings", readings, readingsFlag,
+    dbusIface->register_property_r("Readings", readings,
+                                   sdbusplus::vtable::property_::emits_change,
                                    [this](const auto&) { return readings; });
-    dbusIface->register_property_r(
-        "ReportingType", std::string(), sdbusplus::vtable::property_::const_,
+    dbusIface->register_property_rw(
+        "ReportingType", std::string(),
+        sdbusplus::vtable::property_::emits_change,
+        [this](auto newVal, auto& oldVal) {
+            ReportingType tmp = utils::toReportingType(newVal);
+            if (tmp != reportingType)
+            {
+                if (tmp == ReportingType::onChange)
+                {
+                    throw sdbusplus::exception::SdBusError(
+                        static_cast<int>(std::errc::invalid_argument),
+                        "Invalid reportingType");
+                }
+                if (tmp == ReportingType::periodic)
+                {
+                    if (interval < ReportManager::minInterval)
+                    {
+                        throw sdbusplus::exception::SdBusError(
+                            static_cast<int>(std::errc::invalid_argument),
+                            "Invalid interval");
+                    }
+                    if (enabled == true)
+                    {
+                        scheduleTimer(interval);
+                    }
+                }
+                else
+                {
+                    timer.cancel();
+                }
+                reportingType = tmp;
+                setReadingBuffer(reportUpdates);
+                persistency = storeConfiguration();
+            }
+            oldVal = std::move(newVal);
+            return 1;
+        },
         [this](const auto&) { return utils::enumToString(reportingType); });
     dbusIface->register_property_r(
         "ReadingParameters", readingParametersPastVersion,
         sdbusplus::vtable::property_::const_,
         [this](const auto&) { return readingParametersPastVersion; });
-    dbusIface->register_property_r(
+    dbusIface->register_property_rw(
         "ReadingParametersFutureVersion", readingParameters,
-        sdbusplus::vtable::property_::const_,
+        sdbusplus::vtable::property_::emits_change,
+        [this, &reportFactory](auto newVal, auto& oldVal) {
+            reportFactory.updateMetrics(metrics, enabled, newVal);
+            readingParameters = toReadingParameters(
+                utils::transform(metrics, [](const auto& metric) {
+                    return metric->dumpConfiguration();
+                }));
+            persistency = storeConfiguration();
+            oldVal = std::move(newVal);
+            return 1;
+        },
         [this](const auto&) { return readingParameters; });
     dbusIface->register_property_r(
-        "EmitsReadingsUpdate", bool{}, sdbusplus::vtable::property_::const_,
+        "EmitsReadingsUpdate", bool{}, sdbusplus::vtable::property_::none,
         [this](const auto&) {
-            return utils::contains(reportActions,
-                                   ReportAction::emitsReadingsUpdate);
+            return reportActions.contains(ReportAction::emitsReadingsUpdate);
         });
     dbusIface->register_property_r("Name", std::string{},
                                    sdbusplus::vtable::property_::const_,
@@ -271,15 +320,32 @@
     dbusIface->register_property_r(
         "LogToMetricReportsCollection", bool{},
         sdbusplus::vtable::property_::const_, [this](const auto&) {
-            return utils::contains(reportActions,
-                                   ReportAction::logToMetricReportsCollection);
+            return reportActions.contains(
+                ReportAction::logToMetricReportsCollection);
         });
-    dbusIface->register_property_r(
+    dbusIface->register_property_rw(
         "ReportActions", std::vector<std::string>{},
-        sdbusplus::vtable::property_::const_, [this](const auto&) {
-            return utils::transform(reportActions, [](const auto reportAction) {
-                return utils::enumToString(reportAction);
-            });
+        sdbusplus::vtable::property_::emits_change,
+        [this](auto newVal, auto& oldVal) {
+            auto tmp = utils::transform<std::unordered_set>(
+                newVal, [](const auto& reportAction) {
+                    return utils::toReportAction(reportAction);
+                });
+            tmp.insert(ReportAction::logToMetricReportsCollection);
+
+            if (tmp != reportActions)
+            {
+                reportActions = tmp;
+                persistency = storeConfiguration();
+                oldVal = std::move(newVal);
+            }
+            return 1;
+        },
+        [this](const auto&) {
+            return utils::transform<std::vector>(
+                reportActions, [](const auto reportAction) {
+                    return utils::enumToString(reportAction);
+                });
         });
     dbusIface->register_property_r(
         "AppendLimit", appendLimit.value_or(sensorCount),
@@ -366,7 +432,10 @@
             .count(),
         std::vector<ReadingData>(readingsBuffer.begin(), readingsBuffer.end())};
 
-    reportIface->signal_property("Readings");
+    if (utils::contains(reportActions, ReportAction::emitsReadingsUpdate))
+    {
+        reportIface->signal_property("Readings");
+    }
 }
 
 bool Report::storeConfiguration() const
diff --git a/src/report.hpp b/src/report.hpp
index 5ac6fd0..3b8b451 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -4,6 +4,7 @@
 #include "interfaces/json_storage.hpp"
 #include "interfaces/metric.hpp"
 #include "interfaces/report.hpp"
+#include "interfaces/report_factory.hpp"
 #include "interfaces/report_manager.hpp"
 #include "types/report_action.hpp"
 #include "types/report_types.hpp"
@@ -32,7 +33,8 @@
            interfaces::ReportManager& reportManager,
            interfaces::JsonStorage& reportStorage,
            std::vector<std::shared_ptr<interfaces::Metric>> metrics,
-           const bool enabled, std::unique_ptr<interfaces::Clock> clock);
+           const interfaces::ReportFactory& reportFactory, const bool enabled,
+           std::unique_ptr<interfaces::Clock> clock);
 
     Report(const Report&) = delete;
     Report(Report&&) = delete;
@@ -50,13 +52,15 @@
     }
 
   private:
-    std::unique_ptr<sdbusplus::asio::dbus_interface> makeReportInterface();
+    std::unique_ptr<sdbusplus::asio::dbus_interface>
+        makeReportInterface(const interfaces::ReportFactory& reportFactory);
     static void timerProc(boost::system::error_code, Report& self);
     void scheduleTimer(Milliseconds interval);
     std::optional<uint64_t>
         deduceAppendLimit(const uint64_t appendLimitIn) const;
     uint64_t deduceBufferSize(const ReportUpdates reportUpdatesIn,
                               const ReportingType reportingTypeIn) const;
+    void setReadingBuffer(const ReportUpdates newReportUpdates);
     void setReportUpdates(const ReportUpdates newReportUpdates);
     static uint64_t getSensorCount(
         std::vector<std::shared_ptr<interfaces::Metric>>& metrics);
@@ -70,7 +74,7 @@
     std::string name;
     ReportingType reportingType;
     Milliseconds interval;
-    std::vector<ReportAction> reportActions;
+    std::unordered_set<ReportAction> reportActions;
     ReadingParametersPastVersion readingParametersPastVersion;
     ReadingParameters readingParameters;
     bool persistency = false;
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
index 261fc75..039846e 100644
--- a/src/report_factory.cpp
+++ b/src/report_factory.cpp
@@ -40,10 +40,60 @@
                 std::make_unique<Clock>());
         });
 
-    return std::make_unique<Report>(
-        bus->get_io_context(), objServer, id, name, reportingType,
-        reportActions, period, appendLimit, reportUpdates, reportManager,
-        reportStorage, std::move(metrics), enabled, std::make_unique<Clock>());
+    return std::make_unique<Report>(bus->get_io_context(), objServer, id, name,
+                                    reportingType, reportActions, period,
+                                    appendLimit, reportUpdates, reportManager,
+                                    reportStorage, std::move(metrics), *this,
+                                    enabled, std::make_unique<Clock>());
+}
+
+void ReportFactory::updateMetrics(
+    std::vector<std::shared_ptr<interfaces::Metric>>& metrics, bool enabled,
+    const ReadingParameters& metricParams) const
+{
+    auto labeledMetricParams = convertMetricParams(metricParams);
+    std::vector<std::shared_ptr<interfaces::Metric>> oldMetrics = metrics;
+    std::vector<std::shared_ptr<interfaces::Metric>> newMetrics;
+
+    for (const auto& labeledMetricParam : labeledMetricParams)
+    {
+        auto existing = std::find_if(oldMetrics.begin(), oldMetrics.end(),
+                                     [labeledMetricParam](auto metric) {
+                                         return labeledMetricParam ==
+                                                metric->dumpConfiguration();
+                                     });
+
+        if (existing != oldMetrics.end())
+        {
+            newMetrics.emplace_back(*existing);
+            oldMetrics.erase(existing);
+            continue;
+        }
+
+        namespace ts = utils::tstring;
+        newMetrics.emplace_back(std::make_shared<Metric>(
+            getSensors(labeledMetricParam.at_label<ts::SensorPath>()),
+            labeledMetricParam.at_label<ts::OperationType>(),
+            labeledMetricParam.at_label<ts::Id>(),
+            labeledMetricParam.at_label<ts::CollectionTimeScope>(),
+            labeledMetricParam.at_label<ts::CollectionDuration>(),
+            std::make_unique<Clock>()));
+
+        if (enabled)
+        {
+            newMetrics.back()->initialize();
+        }
+    }
+
+    if (enabled)
+    {
+        for (auto& metric : oldMetrics)
+        {
+            metric->deinitialize();
+        }
+    }
+
+    metrics = std::move(newMetrics);
 }
 
 Sensors ReportFactory::getSensors(
@@ -65,8 +115,30 @@
     boost::asio::yield_context& yield,
     const ReadingParameters& metricParams) const
 {
+    if (metricParams.empty())
+    {
+        return {};
+    }
     auto tree = utils::getSubTreeSensors(yield, bus);
+    return getMetricParamsFromSensorTree(metricParams, tree);
+}
 
+std::vector<LabeledMetricParameters> ReportFactory::convertMetricParams(
+    const ReadingParameters& metricParams) const
+{
+    if (metricParams.empty())
+    {
+        return {};
+    }
+    auto tree = utils::getSubTreeSensors(bus);
+    return getMetricParamsFromSensorTree(metricParams, tree);
+}
+
+std::vector<LabeledMetricParameters>
+    ReportFactory::getMetricParamsFromSensorTree(
+        const ReadingParameters& metricParams,
+        const std::vector<utils::SensorTree>& tree) const
+{
     return utils::transform(metricParams, [&tree](const auto& item) {
         auto [sensorPaths, operationType, id, collectionTimeScope,
               collectionDuration] = item;
diff --git a/src/report_factory.hpp b/src/report_factory.hpp
index 14f9f39..8431f40 100644
--- a/src/report_factory.hpp
+++ b/src/report_factory.hpp
@@ -4,6 +4,7 @@
 #include "interfaces/sensor.hpp"
 #include "sensor_cache.hpp"
 #include "types/sensor_types.hpp"
+#include "utils/dbus_mapper.hpp"
 
 #include <boost/asio/io_context.hpp>
 #include <sdbusplus/asio/object_server.hpp>
@@ -20,6 +21,14 @@
         boost::asio::yield_context& yield,
         const ReadingParameters& metricParams) const override;
 
+    std::vector<LabeledMetricParameters> convertMetricParams(
+        const ReadingParameters& metricParams) const override;
+
+    void
+        updateMetrics(std::vector<std::shared_ptr<interfaces::Metric>>& metrics,
+                      bool enabled,
+                      const ReadingParameters& metricParams) const override;
+
     std::unique_ptr<interfaces::Report>
         make(const std::string& reportId, const std::string& name,
              const ReportingType reportingType,
@@ -33,6 +42,9 @@
 
   private:
     Sensors getSensors(const std::vector<LabeledSensorInfo>& sensorPaths) const;
+    std::vector<LabeledMetricParameters> getMetricParamsFromSensorTree(
+        const ReadingParameters& metricParams,
+        const std::vector<utils::SensorTree>& tree) const;
 
     std::shared_ptr<sdbusplus::asio::connection> bus;
     std::shared_ptr<sdbusplus::asio::object_server> objServer;
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index 31363c4..10035a1 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -56,7 +56,7 @@
                 "SupportedOperationTypes", std::vector<std::string>{},
                 sdbusplus::vtable::property_::const_,
                 [](const auto&) -> std::vector<std::string> {
-                    return utils::transform<std::vector<std::string>>(
+                    return utils::transform<std::vector>(
                         utils::convDataOperationType, [](const auto& item) {
                             return std::string(item.first);
                         });
diff --git a/src/utils/contains.hpp b/src/utils/contains.hpp
index ea1dd16..0a26cc1 100644
--- a/src/utils/contains.hpp
+++ b/src/utils/contains.hpp
@@ -13,6 +13,12 @@
     container.find(container.begin()->first);
 };
 
+template <class T>
+concept HasMemberContains = requires(T container)
+{
+    container.contains(*container.begin());
+};
+
 } // namespace detail
 
 template <detail::HasMemberFind T>
@@ -22,6 +28,12 @@
     return container.find(key) != container.end();
 }
 
+template <detail::HasMemberContains T>
+inline bool contains(const T& container, const typename T::value_type& key)
+{
+    return container.contains(key);
+}
+
 template <class T>
 inline bool contains(const T& container, const typename T::value_type& key)
 {
diff --git a/src/utils/transform.hpp b/src/utils/transform.hpp
index 4a28950..fc52fc3 100644
--- a/src/utils/transform.hpp
+++ b/src/utils/transform.hpp
@@ -16,27 +16,29 @@
 
 } // namespace detail
 
-template <class R, class Container, class F>
-auto transform(const Container& container, F&& functor)
+template <template <class, class...> class R, class Container, class Functor>
+inline auto transform(const Container& container, Functor&& f)
 {
-    auto result = R{};
+    auto result = R<decltype(f(*container.begin()))>{};
 
     if constexpr (detail::has_member_reserve<decltype(result)>)
     {
         result.reserve(container.size());
     }
+
     std::transform(container.begin(), container.end(),
                    std::inserter(result, result.end()),
-                   std::forward<F>(functor));
+                   std::forward<Functor>(f));
+
     return result;
 }
 
-template <template <class, class...> class Container, class T, class... Args,
-          class F>
-auto transform(const Container<T, Args...>& container, F&& functor)
+template <template <class, class...> class Container, class Functor,
+          class... Args>
+inline auto transform(const Container<Args...>& container, Functor&& f)
 {
-    using R = Container<decltype(functor(*container.begin()))>;
-    return transform<R>(container, std::forward<F>(functor));
+    return transform<Container, Container<Args...>, Functor>(
+        container, std::forward<Functor>(f));
 }
 
 } // namespace utils