diff --git a/include/event_service_store.hpp b/include/event_service_store.hpp
new file mode 100644
index 0000000..d51adad
--- /dev/null
+++ b/include/event_service_store.hpp
@@ -0,0 +1,264 @@
+#pragma once
+#include "logging.hpp"
+
+#include <boost/container/flat_map.hpp>
+#include <nlohmann/json.hpp>
+
+namespace persistent_data
+{
+
+struct UserSubscription
+{
+    std::string id;
+    std::string destinationUrl;
+    std::string protocol;
+    std::string retryPolicy;
+    std::string customText;
+    std::string eventFormatType;
+    std::string subscriptionType;
+    std::vector<std::string> registryMsgIds;
+    std::vector<std::string> registryPrefixes;
+    std::vector<std::string> resourceTypes;
+    std::vector<nlohmann::json> httpHeaders; // key-value pair
+    std::vector<std::string> metricReportDefinitions;
+
+    static std::shared_ptr<UserSubscription>
+        fromJson(const nlohmann::json& j, const bool loadFromOldConfig = false)
+    {
+        std::shared_ptr<UserSubscription> subvalue =
+            std::make_shared<UserSubscription>();
+        for (const auto& element : j.items())
+        {
+            if (element.key() == "Id")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->id = *value;
+            }
+            else if (element.key() == "Destination")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->destinationUrl = *value;
+            }
+            else if (element.key() == "Protocol")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->protocol = *value;
+            }
+            else if (element.key() == "DeliveryRetryPolicy")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->retryPolicy = *value;
+            }
+            else if (element.key() == "Context")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->customText = *value;
+            }
+            else if (element.key() == "EventFormatType")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->eventFormatType = *value;
+            }
+            else if (element.key() == "SubscriptionType")
+            {
+                const std::string* value =
+                    element.value().get_ptr<const std::string*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                subvalue->subscriptionType = *value;
+            }
+            else if (element.key() == "MessageIds")
+            {
+                const auto& obj = element.value();
+                for (const auto& val : obj.items())
+                {
+                    const std::string* value =
+                        val.value().get_ptr<const std::string*>();
+                    if (value == nullptr)
+                    {
+                        continue;
+                    }
+                    subvalue->registryMsgIds.emplace_back(*value);
+                }
+            }
+            else if (element.key() == "RegistryPrefixes")
+            {
+                const auto& obj = element.value();
+                for (const auto& val : obj.items())
+                {
+                    const std::string* value =
+                        val.value().get_ptr<const std::string*>();
+                    if (value == nullptr)
+                    {
+                        continue;
+                    }
+                    subvalue->registryPrefixes.emplace_back(*value);
+                }
+            }
+            else if (element.key() == "ResourceTypes")
+            {
+                const auto& obj = element.value();
+                for (const auto& val : obj.items())
+                {
+                    const std::string* value =
+                        val.value().get_ptr<const std::string*>();
+                    if (value == nullptr)
+                    {
+                        continue;
+                    }
+                    subvalue->resourceTypes.emplace_back(*value);
+                }
+            }
+            else if (element.key() == "HttpHeaders")
+            {
+                const auto& obj = element.value();
+                for (const auto& val : obj.items())
+                {
+                    const auto value =
+                        val.value().get_ptr<const nlohmann::json::object_t*>();
+                    if (value == nullptr)
+                    {
+                        continue;
+                    }
+                    subvalue->httpHeaders.emplace_back(*value);
+                }
+            }
+            else if (element.key() == "MetricReportDefinitions")
+            {
+                const auto& obj = element.value();
+                for (const auto& val : obj.items())
+                {
+                    const std::string* value =
+                        val.value().get_ptr<const std::string*>();
+                    if (value == nullptr)
+                    {
+                        continue;
+                    }
+                    subvalue->metricReportDefinitions.emplace_back(*value);
+                }
+            }
+            else
+            {
+                BMCWEB_LOG_ERROR
+                    << "Got unexpected property reading persistent file: "
+                    << element.key();
+                continue;
+            }
+        }
+
+        if ((subvalue->id.empty() && !loadFromOldConfig) ||
+            subvalue->destinationUrl.empty() || subvalue->protocol.empty() ||
+            subvalue->retryPolicy.empty() || subvalue->customText.empty() ||
+            subvalue->eventFormatType.empty() ||
+            subvalue->subscriptionType.empty() ||
+            (subvalue->registryPrefixes.empty() &&
+             subvalue->registryMsgIds.empty()))
+        {
+            BMCWEB_LOG_ERROR << "Subscription missing required field "
+                                "information, refusing to restore";
+            return nullptr;
+        }
+
+        return subvalue;
+    }
+};
+
+struct EventServiceConfig
+{
+    bool enabled = true;
+    uint32_t retryAttempts = 3;
+    uint32_t retryTimeoutInterval = 30;
+
+    void fromJson(const nlohmann::json& j)
+    {
+        for (const auto& element : j.items())
+        {
+            if (element.key() == "ServiceEnabled")
+            {
+                const bool* value = element.value().get_ptr<const bool*>();
+                if (value == nullptr)
+                {
+                    continue;
+                }
+                enabled = *value;
+            }
+            else if (element.key() == "DeliveryRetryAttempts")
+            {
+                const uint64_t* value =
+                    element.value().get_ptr<const uint64_t*>();
+                if ((value == nullptr) ||
+                    (*value < std::numeric_limits<uint32_t>::lowest()) ||
+                    (*value > std::numeric_limits<uint32_t>::max()))
+                {
+                    continue;
+                }
+                retryAttempts = static_cast<uint32_t>(*value);
+            }
+            else if (element.key() == "DeliveryRetryIntervalSeconds")
+            {
+                const uint64_t* value =
+                    element.value().get_ptr<const uint64_t*>();
+                if ((value == nullptr) ||
+                    (*value < std::numeric_limits<uint32_t>::lowest()) ||
+                    (*value > std::numeric_limits<uint32_t>::max()))
+                {
+                    continue;
+                }
+                retryTimeoutInterval = static_cast<uint32_t>(*value);
+            }
+        }
+    }
+};
+
+class EventServiceStore
+{
+  public:
+    boost::container::flat_map<std::string, std::shared_ptr<UserSubscription>>
+        subscriptionsConfigMap;
+    EventServiceConfig eventServiceConfig;
+
+    static EventServiceStore& getInstance()
+    {
+        static EventServiceStore eventServiceStore;
+        return eventServiceStore;
+    }
+
+    EventServiceConfig& getEventServiceConfig()
+    {
+        return eventServiceConfig;
+    }
+};
+
+} // namespace persistent_data
diff --git a/include/persistent_data.hpp b/include/persistent_data.hpp
index 24f7afd..4178d7d 100644
--- a/include/persistent_data.hpp
+++ b/include/persistent_data.hpp
@@ -5,6 +5,7 @@
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
+#include <event_service_store.hpp>
 #include <http_request.hpp>
 #include <http_response.hpp>
 #include <nlohmann/json.hpp>
@@ -129,6 +130,35 @@
                         SessionStore::getInstance().updateSessionTimeout(
                             sessionTimeoutInseconds);
                     }
+                    else if (item.key() == "eventservice_config")
+                    {
+                        EventServiceStore::getInstance()
+                            .getEventServiceConfig()
+                            .fromJson(item.value());
+                    }
+                    else if (item.key() == "subscriptions")
+                    {
+                        for (const auto& elem : item.value())
+                        {
+                            std::shared_ptr<UserSubscription> newSubscription =
+                                UserSubscription::fromJson(elem);
+
+                            if (newSubscription == nullptr)
+                            {
+                                BMCWEB_LOG_ERROR
+                                    << "Problem reading subscription "
+                                       "from persistent store";
+                                continue;
+                            }
+
+                            BMCWEB_LOG_DEBUG << "Restored subscription: "
+                                             << newSubscription->id << " "
+                                             << newSubscription->customText;
+                            EventServiceStore::getInstance()
+                                .subscriptionsConfigMap.emplace(
+                                    newSubscription->id, newSubscription);
+                        }
+                    }
                     else
                     {
                         // Do nothing in the case of extra fields.  We may have
@@ -170,6 +200,8 @@
             std::filesystem::perms::group_read;
         std::filesystem::permissions(filename, permission);
         const auto& c = SessionStore::getInstance().getAuthMethodsConfig();
+        const auto& eventServiceConfig =
+            EventServiceStore::getInstance().getEventServiceConfig();
         nlohmann::json data{
             {"auth_config",
              {{"XToken", c.xtoken},
@@ -179,6 +211,13 @@
               {"TLS", c.tls}}
 
             },
+            {"eventservice_config",
+             {{"ServiceEnabled", eventServiceConfig.enabled},
+              {"DeliveryRetryAttempts", eventServiceConfig.retryAttempts},
+              {"DeliveryRetryIntervalSeconds",
+               eventServiceConfig.retryTimeoutInterval}}
+
+            },
             {"system_uuid", systemUuid},
             {"revision", jsonRevision},
             {"timeout", SessionStore::getInstance().getTimeoutInSeconds()}};
@@ -202,6 +241,34 @@
                 });
             }
         }
+        nlohmann::json& subscriptions = data["subscriptions"];
+        subscriptions = nlohmann::json::array();
+        for (const auto& it :
+             EventServiceStore::getInstance().subscriptionsConfigMap)
+        {
+            std::shared_ptr<UserSubscription> subValue = it.second;
+            if (subValue->subscriptionType == "SSE")
+            {
+                BMCWEB_LOG_DEBUG
+                    << "The subscription type is SSE, so skipping.";
+                continue;
+            }
+            subscriptions.push_back({
+                {"Id", subValue->id},
+                {"Context", subValue->customText},
+                {"DeliveryRetryPolicy", subValue->retryPolicy},
+                {"Destination", subValue->destinationUrl},
+                {"EventFormatType", subValue->eventFormatType},
+                {"HttpHeaders", subValue->httpHeaders},
+                {"MessageIds", subValue->registryMsgIds},
+                {"Protocol", subValue->protocol},
+                {"RegistryPrefixes", subValue->registryPrefixes},
+                {"ResourceTypes", subValue->resourceTypes},
+                {"SubscriptionType", subValue->subscriptionType},
+                {"MetricReportDefinitions", subValue->metricReportDefinitions},
+
+            });
+        }
         persistentFile << data;
     }