diff --git a/src/report.cpp b/src/report.cpp
index 540418a..be98c6d 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -39,7 +39,7 @@
                    deduceBufferSize(reportUpdates, reportingType)),
     objServer(objServer), metrics(std::move(metricsIn)), timer(ioc),
     triggerIds(collectTriggerIds(ioc)), reportStorage(reportStorageIn),
-    enabled(enabledIn), clock(std::move(clock)), messanger(ioc)
+    clock(std::move(clock)), messanger(ioc)
 {
     readingParameters =
         toReadingParameters(utils::transform(metrics, [](const auto& metric) {
@@ -75,18 +75,12 @@
             });
         });
 
-    persistency = storeConfiguration();
+    errorMessages = verify();
+    state.set<ReportFlags::enabled, ReportFlags::valid>(enabledIn,
+                                                        errorMessages.empty());
+
     reportIface = makeReportInterface(reportFactory);
-
-    updateReportingType(reportingType);
-
-    if (enabled)
-    {
-        for (auto& metric : this->metrics)
-        {
-            metric->initialize();
-        }
-    }
+    persistency = storeConfiguration();
 
     messanger.on_receive<messages::TriggerPresenceChangedInd>(
         [this](const auto& msg) {
@@ -137,6 +131,37 @@
     }
 }
 
+void Report::activate()
+{
+    for (auto& metric : this->metrics)
+    {
+        metric->initialize();
+    }
+
+    scheduleTimer();
+
+    if (reportIface)
+    {
+        reportIface->signal_property("errors");
+    }
+}
+
+void Report::deactivate()
+{
+    for (auto& metric : metrics)
+    {
+        metric->deinitialize();
+    }
+
+    unregisterFromMetrics = nullptr;
+    timer.cancel();
+
+    if (reportIface)
+    {
+        reportIface->signal_property("Errors");
+    }
+}
+
 uint64_t Report::getSensorCount(
     const std::vector<std::shared_ptr<interfaces::Metric>>& metrics)
 {
@@ -200,70 +225,71 @@
 {
     auto dbusIface =
         objServer->add_unique_interface(getPath(), reportIfaceName);
-    dbusIface->register_property_rw(
-        "Enabled", enabled, sdbusplus::vtable::property_::emits_change,
-        [this](bool newVal, const auto&) {
-            if (newVal != enabled)
+    dbusIface->register_property_rw<bool>(
+        "Enabled", sdbusplus::vtable::property_::emits_change,
+        [this](bool newVal, auto& oldValue) {
+            if (newVal != state.get<ReportFlags::enabled>())
             {
-                if (true == newVal && ReportingType::periodic == reportingType)
-                {
-                    scheduleTimerForPeriodicReport(interval);
-                }
-                if (newVal)
-                {
-                    for (auto& metric : metrics)
-                    {
-                        metric->initialize();
-                    }
-                }
-                else
-                {
-                    for (auto& metric : metrics)
-                    {
-                        metric->deinitialize();
-                    }
-                }
+                state.set<ReportFlags::enabled>(oldValue = newVal);
 
-                enabled = newVal;
                 persistency = storeConfiguration();
             }
             return 1;
         },
-        [this](const auto&) { return enabled; });
-    dbusIface->register_property_rw(
-        "Interval", interval.count(),
-        sdbusplus::vtable::property_::emits_change,
-        [this](uint64_t newVal, auto&) {
-            if (Milliseconds newValT{newVal};
-                newValT >= ReportManager::minInterval)
+        [this](const auto&) { return state.get<ReportFlags::enabled>(); });
+    dbusIface->register_property_r<
+        std::vector<std::tuple<std::string, std::string>>>(
+        "ErrorMessages", sdbusplus::vtable::property_::emits_change,
+        [this](const auto&) {
+            return utils::transform(errorMessages, [](const auto& em) {
+                return std::tuple<std::string, std::string>(
+                    utils::enumToString(em.error), em.arg0);
+            });
+        });
+    dbusIface->register_property_rw<uint64_t>(
+        "Interval", sdbusplus::vtable::property_::emits_change,
+        [this](uint64_t newVal, auto& oldVal) {
+            const Milliseconds newValT{newVal};
+            if (newValT < ReportManager::minInterval &&
+                newValT != Milliseconds{0})
             {
-                if (newValT != interval)
-                {
-                    interval = newValT;
-                    persistency = storeConfiguration();
-                }
-                return 1;
+                throw sdbusplus::exception::SdBusError(
+                    static_cast<int>(std::errc::invalid_argument),
+                    "Invalid interval");
             }
-            throw sdbusplus::exception::SdBusError(
-                static_cast<int>(std::errc::invalid_argument),
-                "Invalid interval");
+
+            if (newValT != interval)
+            {
+                oldVal = newVal;
+                interval = newValT;
+
+                errorMessages = verify();
+                if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
+                    StateEvent::active)
+                {
+                    scheduleTimer();
+                }
+
+                persistency = storeConfiguration();
+            }
+            return 1;
         },
         [this](const auto&) { return interval.count(); });
-    dbusIface->register_property_rw(
-        "Persistency", persistency, sdbusplus::vtable::property_::emits_change,
-        [this](bool newVal, const auto&) {
+    dbusIface->register_property_rw<bool>(
+        "Persistency", sdbusplus::vtable::property_::emits_change,
+        [this](bool newVal, auto& oldVal) {
             if (newVal == persistency)
             {
                 return 1;
             }
             if (newVal)
             {
-                persistency = storeConfiguration();
+                persistency = oldVal = storeConfiguration();
             }
             else
             {
                 reportStorage.remove(reportFileName());
-                persistency = false;
+                persistency = oldVal = false;
             }
             return 1;
         },
@@ -272,27 +298,25 @@
     dbusIface->register_property_r("Readings", readings,
                                    sdbusplus::vtable::property_::emits_change,
                                    [this](const auto&) { return readings; });
-    dbusIface->register_property_rw(
-        "ReportingType", std::string(),
-        sdbusplus::vtable::property_::emits_change,
+    dbusIface->register_property_rw<std::string>(
+        "ReportingType", sdbusplus::vtable::property_::emits_change,
         [this](auto newVal, auto& oldVal) {
             ReportingType tmp = utils::toReportingType(newVal);
             if (tmp != reportingType)
             {
-                if (tmp == ReportingType::periodic)
+                reportingType = tmp;
+                oldVal = std::move(newVal);
+
+                errorMessages = verify();
+                if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
+                    StateEvent::active)
                 {
-                    if (interval < ReportManager::minInterval)
-                    {
-                        throw sdbusplus::exception::SdBusError(
-                            static_cast<int>(std::errc::invalid_argument),
-                            "Invalid interval");
-                    }
+                    scheduleTimer();
                 }
 
-                updateReportingType(tmp);
-                setReadingBuffer(reportUpdates);
                 persistency = storeConfiguration();
-                oldVal = std::move(newVal);
+
+                setReadingBuffer(reportUpdates);
             }
             return 1;
         },
@@ -305,7 +329,8 @@
         "ReadingParametersFutureVersion", readingParameters,
         sdbusplus::vtable::property_::emits_change,
         [this, &reportFactory](auto newVal, auto& oldVal) {
-            reportFactory.updateMetrics(metrics, enabled, newVal);
+            reportFactory.updateMetrics(
+                metrics, state.get<ReportFlags::enabled>(), newVal);
             readingParameters = toReadingParameters(
                 utils::transform(metrics, [](const auto& metric) {
                     return metric->dumpConfiguration();
@@ -315,23 +340,22 @@
             return 1;
         },
         [this](const auto&) { return readingParameters; });
-    dbusIface->register_property_r(
-        "EmitsReadingsUpdate", bool{}, sdbusplus::vtable::property_::none,
+    dbusIface->register_property_r<bool>(
+        "EmitsReadingsUpdate", sdbusplus::vtable::property_::none,
         [this](const auto&) {
             return reportActions.contains(ReportAction::emitsReadingsUpdate);
         });
-    dbusIface->register_property_r("Name", std::string{},
-                                   sdbusplus::vtable::property_::const_,
-                                   [this](const auto&) { return name; });
-    dbusIface->register_property_r(
-        "LogToMetricReportsCollection", bool{},
-        sdbusplus::vtable::property_::const_, [this](const auto&) {
+    dbusIface->register_property_r<std::string>(
+        "Name", sdbusplus::vtable::property_::const_,
+        [this](const auto&) { return name; });
+    dbusIface->register_property_r<bool>(
+        "LogToMetricReportsCollection", sdbusplus::vtable::property_::const_,
+        [this](const auto&) {
             return reportActions.contains(
                 ReportAction::logToMetricReportsCollection);
         });
-    dbusIface->register_property_rw(
-        "ReportActions", std::vector<std::string>{},
-        sdbusplus::vtable::property_::emits_change,
+    dbusIface->register_property_rw<std::vector<std::string>>(
+        "ReportActions", sdbusplus::vtable::property_::emits_change,
         [this](auto newVal, auto& oldVal) {
             auto tmp = utils::transform<std::unordered_set>(
                 newVal, [](const auto& reportAction) {
@@ -420,11 +444,6 @@
 
 void Report::scheduleTimerForPeriodicReport(Milliseconds timerInterval)
 {
-    if (!enabled)
-    {
-        return;
-    }
-
     timer.expires_after(timerInterval);
     timer.async_wait([this](boost::system::error_code ec) {
         timerProcForPeriodicReport(ec, *this);
@@ -433,11 +452,6 @@
 
 void Report::scheduleTimerForOnChangeReport()
 {
-    if (!enabled)
-    {
-        return;
-    }
-
     constexpr Milliseconds timerInterval{100};
 
     timer.expires_after(timerInterval);
@@ -448,7 +462,7 @@
 
 void Report::updateReadings()
 {
-    if (!enabled)
+    if (!state.isActive())
     {
         return;
     }
@@ -461,17 +475,19 @@
 
     for (const auto& metric : metrics)
     {
+        if (!state.isActive())
+        {
+            break;
+        }
+
         for (const auto& [id, metadata, value, timestamp] :
              metric->getUpdatedReadings())
         {
             if (reportUpdates == ReportUpdates::appendStopsWhenFull &&
                 readingsBuffer.isFull())
             {
-                enabled = false;
-                for (auto& m : metrics)
-                {
-                    m->deinitialize();
-                }
+                state.set<ReportFlags::enabled>(false);
+                reportIface->signal_property("Enabled");
                 break;
             }
             readingsBuffer.emplace(id, metadata, value, timestamp);
@@ -500,7 +516,7 @@
     {
         nlohmann::json data;
 
-        data["Enabled"] = enabled;
+        data["Enabled"] = state.get<ReportFlags::enabled>();
         data["Version"] = reportVersion;
         data["Id"] = id;
         data["Name"] = name;
@@ -568,37 +584,37 @@
     updateReadings();
 }
 
-void Report::updateReportingType(ReportingType newReportingType)
+void Report::scheduleTimer()
 {
-    if (reportingType != newReportingType)
-    {
-        timer.cancel();
-        unregisterFromMetrics = nullptr;
-    }
-
-    reportingType = newReportingType;
-
     switch (reportingType)
     {
         case ReportingType::periodic:
         {
+            unregisterFromMetrics = nullptr;
             scheduleTimerForPeriodicReport(interval);
             break;
         }
         case ReportingType::onChange:
         {
-            unregisterFromMetrics = [this] {
+            if (!unregisterFromMetrics)
+            {
+                unregisterFromMetrics = [this] {
+                    for (auto& metric : metrics)
+                    {
+                        metric->unregisterFromUpdates(*this);
+                    }
+                };
+
                 for (auto& metric : metrics)
                 {
-                    metric->unregisterFromUpdates(*this);
+                    metric->registerForUpdates(*this);
                 }
-            };
+            }
 
             bool isTimerRequired = false;
 
             for (auto& metric : metrics)
             {
-                metric->registerForUpdates(*this);
                 if (metric->isTimerRequired())
                 {
                     isTimerRequired = true;
@@ -609,9 +625,31 @@
             {
                 scheduleTimerForOnChangeReport();
             }
+            else
+            {
+                timer.cancel();
+            }
             break;
         }
         default:
+            unregisterFromMetrics = nullptr;
+            timer.cancel();
             break;
     }
 }
+
+std::vector<ErrorMessage> Report::verify() const
+{
+    std::vector<ErrorMessage> result;
+
+    if ((reportingType == ReportingType::periodic &&
+         interval == Milliseconds{0}) ||
+        (reportingType != ReportingType::periodic &&
+         interval != Milliseconds{0}))
+    {
+        result.emplace_back(ErrorType::propertyConflict, "Interval");
+        result.emplace_back(ErrorType::propertyConflict, "ReportingType");
+    }
+
+    return result;
+}
diff --git a/src/report.hpp b/src/report.hpp
index 6d8c6b4..7609297 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -7,6 +7,8 @@
 #include "interfaces/report.hpp"
 #include "interfaces/report_factory.hpp"
 #include "interfaces/report_manager.hpp"
+#include "state.hpp"
+#include "types/error_message.hpp"
 #include "types/readings.hpp"
 #include "types/report_action.hpp"
 #include "types/report_types.hpp"
@@ -81,6 +83,9 @@
 
     void metricUpdated() override;
 
+    void activate();
+    void deactivate();
+
   private:
     std::unique_ptr<sdbusplus::asio::dbus_interface>
         makeReportInterface(const interfaces::ReportFactory& reportFactory);
@@ -104,7 +109,8 @@
     bool storeConfiguration() const;
     bool shouldStoreMetricValues() const;
     void updateReadings();
-    void updateReportingType(ReportingType);
+    void scheduleTimer();
+    std::vector<ErrorMessage> verify() const;
 
     std::string id;
     std::string name;
@@ -127,11 +133,13 @@
     std::unordered_set<std::string> triggerIds;
 
     interfaces::JsonStorage& reportStorage;
-    bool enabled;
     std::unique_ptr<interfaces::Clock> clock;
     utils::Messanger messanger;
     std::optional<OnChangeContext> onChangeContext;
     utils::Ensure<std::function<void()>> unregisterFromMetrics;
+    State<ReportFlags, Report, ReportFlags::enabled, ReportFlags::valid> state{
+        *this};
+    std::vector<ErrorMessage> errorMessages;
 
   public:
     static constexpr const char* reportIfaceName =
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index 926b642..738dd6d 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -154,7 +154,9 @@
             "Append limit out of range");
     }
 
-    if (reportingType == ReportingType::periodic && interval < minInterval)
+    if ((reportingType == ReportingType::periodic && interval < minInterval) ||
+        (reportingType != ReportingType::periodic &&
+         interval != Milliseconds{0}))
     {
         throw sdbusplus::exception::SdBusError(
             static_cast<int>(std::errc::invalid_argument), "Invalid interval");
diff --git a/src/state.hpp b/src/state.hpp
new file mode 100644
index 0000000..91a7daf
--- /dev/null
+++ b/src/state.hpp
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <bitset>
+
+enum class ReportFlags
+{
+    enabled,
+    valid
+};
+
+enum class StateEvent
+{
+    active,
+    inactive,
+    activated,
+    deactivated
+};
+
+template <class T>
+concept boolean = std::is_same_v<T, bool>;
+
+template <class Flags, class Object, Flags... Keys>
+class State
+{
+  public:
+    explicit State(Object& object) : object(object)
+    {}
+
+    template <Flags... Indexes>
+    StateEvent set(boolean auto... values)
+    {
+        static_assert(sizeof...(Indexes) == sizeof...(values));
+
+        const bool previous = flags.all();
+
+        (flags.set(indexOf<0, Indexes, Keys...>(), values), ...);
+
+        if (previous != flags.all())
+        {
+            if (flags.all())
+            {
+                object.activate();
+                return StateEvent::activated;
+            }
+            else
+            {
+                object.deactivate();
+                return StateEvent::deactivated;
+            }
+        }
+
+        return flags.all() ? StateEvent::active : StateEvent::inactive;
+    }
+
+    template <Flags Index>
+    bool get() const
+    {
+        return flags.test(indexOf<0, Index, Keys...>());
+    }
+
+    bool isActive() const
+    {
+        return flags.all();
+    }
+
+  private:
+    template <size_t Index, Flags flag, Flags it, Flags... list>
+    static constexpr size_t indexOf()
+    {
+        if constexpr (flag == it)
+        {
+            return Index;
+        }
+        else
+        {
+            return indexOf<Index + 1, flag, list...>();
+        }
+    }
+
+    Object& object;
+    std::bitset<sizeof...(Keys)> flags{0};
+};
diff --git a/src/types/error_message.hpp b/src/types/error_message.hpp
new file mode 100644
index 0000000..de27772
--- /dev/null
+++ b/src/types/error_message.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "error_type.hpp"
+
+#include <string>
+
+struct ErrorMessage
+{
+    ErrorType error;
+    std::string arg0;
+};
diff --git a/src/types/error_type.hpp b/src/types/error_type.hpp
new file mode 100644
index 0000000..0f1d61e
--- /dev/null
+++ b/src/types/error_type.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "utils/conversion.hpp"
+
+#include <sdbusplus/exception.hpp>
+
+#include <array>
+#include <cstdint>
+#include <string_view>
+#include <type_traits>
+
+enum class ErrorType : uint32_t
+{
+    propertyConflict
+};
+
+namespace utils
+{
+
+constexpr auto convDataErrorType =
+    std::array{std::make_pair<std::string_view, ErrorType>(
+        "PropertyConflict", ErrorType::propertyConflict)};
+
+inline ErrorType toErrorType(std::underlying_type_t<ErrorType> value)
+{
+    return toEnum<ErrorType, minEnumValue(convDataErrorType),
+                  maxEnumValue(convDataErrorType)>(value);
+}
+
+inline ErrorType toErrorType(const std::string& value)
+{
+    return toEnum(convDataErrorType, value);
+}
+
+inline std::string enumToString(ErrorType value)
+{
+    return std::string(enumToString(convDataErrorType, value));
+}
+
+} // namespace utils
diff --git a/src/utils/ensure.hpp b/src/utils/ensure.hpp
index cbe69c5..8f266ab 100644
--- a/src/utils/ensure.hpp
+++ b/src/utils/ensure.hpp
@@ -53,6 +53,11 @@
 
     Ensure& operator=(const Ensure&) = delete;
 
+    explicit operator bool() const
+    {
+        return static_cast<bool>(functor);
+    }
+
   private:
     void clear()
     {