diff --git a/Makefile.am b/Makefile.am
index 7f58aa3..60cac80 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -4,7 +4,8 @@
 phosphor_ledmanager_SOURCES = \
                 led-main.cpp  \
                 manager.cpp \
-                group.cpp
+                group.cpp \
+                serialize.cpp
 
 if !WANTS_JSON
 BUILT_SOURCES = led-gen.hpp
diff --git a/configure.ac b/configure.ac
index 5a9c2e0..f871477 100644
--- a/configure.ac
+++ b/configure.ac
@@ -71,6 +71,10 @@
 AS_IF([test "x$LED_JSON_FILE" == "x"], [LED_JSON_FILE="/usr/share/phosphor-led-manager/led-group-config.json"])
 AC_DEFINE_UNQUOTED([LED_JSON_FILE], ["$LED_JSON_FILE"], [The LED configuration JSON file])
 
+AC_ARG_VAR(CLASS_VERSION, [Class version to register with Cereal])
+AS_IF([test "x$CLASS_VERSION" == "x"], [CLASS_VERSION=1])
+AC_DEFINE_UNQUOTED([CLASS_VERSION], [$CLASS_VERSION], [Class version to register with Cereal])
+
 # enable JSON configuration
 AC_ARG_ENABLE([use_json],
     AS_HELP_STRING([--enable-use_json], [Enable JSON configuration.]))
@@ -79,6 +83,11 @@
     AC_DEFINE([LED_USE_JSON],[],[Enable JSON configuration.])
 )
 
+# Path of file for storing the names of asserted groups
+AC_ARG_VAR(SAVED_GROUPS_FILE, [Path of file for storing the names of asserted groups])
+AS_IF([test "x$SAVED_GROUPS_FILE" == "x"], [SAVED_GROUPS_FILE="/var/lib/phosphor-led-manager/savedGroups"])
+AC_DEFINE_UNQUOTED([SAVED_GROUPS_FILE], ["$SAVED_GROUPS_FILE"], [Path of file for storing the names of asserted groups])
+
 AC_DEFINE(CALLOUT_FWD_ASSOCIATION, "callout", [The name of the callout's forward association.])
 AC_DEFINE(CALLOUT_REV_ASSOCIATION, "fault", [The name of the callout's reverse association.])
 AC_DEFINE(ELOG_ENTRY, "entry", [Path element indicates an error log entry under logging namespace.])
diff --git a/group.cpp b/group.cpp
index 0d4fa10..fc2cef6 100644
--- a/group.cpp
+++ b/group.cpp
@@ -1,3 +1,5 @@
+#include "config.h"
+
 #include "group.hpp"
 
 #include <sdbusplus/message.hpp>
@@ -18,6 +20,9 @@
     // validation.
     auto result = manager.setGroupState(path, value, ledsAssert, ledsDeAssert);
 
+    // Store asserted state
+    serialize.storeGroups(path, result);
+
     // If something does not go right here, then there should be an sdbusplus
     // exception thrown.
     manager.driveLEDs(ledsAssert, ledsDeAssert);
diff --git a/group.hpp b/group.hpp
index fdfcf55..7bf97c6 100644
--- a/group.hpp
+++ b/group.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "manager.hpp"
+#include "serialize.hpp"
 
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
@@ -31,18 +32,26 @@
     /** @brief Constructs LED Group
      *
      * @param[in] bus     - Handle to system dbus
-     * @param[in] objPath - The Dbus path that hosts LED group
+     * @param[in] objPath - The D-Bus path that hosts LED group
      * @param[in] manager - Reference to Manager
+     * @param[in] serialize - Serialize object
      */
     Group(sdbusplus::bus::bus& bus, const std::string& objPath,
-          Manager& manager) :
+          Manager& manager, Serialize& serialize) :
 
         sdbusplus::server::object::object<
             sdbusplus::xyz::openbmc_project::Led::server::Group>(
-            bus, objPath.c_str()),
-        path(objPath), manager(manager)
+            bus, objPath.c_str(), true),
+        path(objPath), manager(manager), serialize(serialize)
     {
-        // Nothing to do here
+        // Initialize Asserted property value
+        if (serialize.getGroupSavedState(objPath))
+        {
+            asserted(true);
+        }
+
+        // Emit deferred signal.
+        emit_object_added();
     }
 
     /** @brief Property SET Override function
@@ -58,6 +67,9 @@
 
     /** @brief Reference to Manager object */
     Manager& manager;
+
+    /** @brief The serialize class for storing and restoring groups of LEDs */
+    Serialize& serialize;
 };
 
 } // namespace led
diff --git a/led-main.cpp b/led-main.cpp
index 53e3a71..0b060dc 100644
--- a/led-main.cpp
+++ b/led-main.cpp
@@ -8,6 +8,7 @@
 #endif
 #include "ledlayout.hpp"
 #include "manager.hpp"
+#include "serialize.hpp"
 
 #include <iostream>
 
@@ -29,11 +30,14 @@
     /** @brief vector of led groups */
     std::vector<std::unique_ptr<phosphor::led::Group>> groups;
 
+    /** @brief store and re-store Group */
+    phosphor::led::Serialize serialize(SAVED_GROUPS_FILE);
+
     /** Now create so many dbus objects as there are groups */
     for (auto& grp : systemLedMap)
     {
-        groups.emplace_back(
-            std::make_unique<phosphor::led::Group>(bus, grp.first, manager));
+        groups.emplace_back(std::make_unique<phosphor::led::Group>(
+            bus, grp.first, manager, serialize));
     }
 
     /** @brief Claim the bus */
diff --git a/serialize.cpp b/serialize.cpp
new file mode 100644
index 0000000..cd48a8c
--- /dev/null
+++ b/serialize.cpp
@@ -0,0 +1,81 @@
+#include "config.h"
+
+#include "serialize.hpp"
+
+#include <cereal/archives/json.hpp>
+#include <cereal/types/set.hpp>
+#include <cereal/types/string.hpp>
+#include <phosphor-logging/log.hpp>
+
+#include <filesystem>
+#include <fstream>
+
+// Register class version with Cereal
+CEREAL_CLASS_VERSION(phosphor::led::Serialize, CLASS_VERSION);
+
+namespace phosphor
+{
+namespace led
+{
+
+namespace fs = std::filesystem;
+
+bool Serialize::getGroupSavedState(const std::string& objPath) const
+{
+    return savedGroups.find(objPath) == savedGroups.end() ? false : true;
+}
+
+void Serialize::storeGroups(const std::string& group, bool asserted)
+{
+    // If the name of asserted group does not exist in the archive and the
+    // Asserted property is true, it is inserted into archive.
+    // If the name of asserted group exist in the archive and the Asserted
+    // property is false, entry is removed from the archive.
+    auto iter = savedGroups.find(group);
+    if (iter != savedGroups.end() && asserted == false)
+    {
+        savedGroups.erase(iter);
+    }
+
+    if (iter == savedGroups.end() && asserted)
+    {
+        savedGroups.emplace(group);
+    }
+
+    auto dir = path.parent_path();
+    if (!fs::exists(dir))
+    {
+        fs::create_directories(dir);
+    }
+
+    std::ofstream os(path.c_str(), std::ios::binary);
+    cereal::JSONOutputArchive oarchive(os);
+    oarchive(savedGroups);
+}
+
+void Serialize::restoreGroups()
+{
+    using namespace phosphor::logging;
+
+    if (!fs::exists(path))
+    {
+        log<level::INFO>("File does not exist",
+                         entry("FILE_PATH=%s", path.c_str()));
+        return;
+    }
+
+    try
+    {
+        std::ifstream is(path.c_str(), std::ios::in | std::ios::binary);
+        cereal::JSONInputArchive iarchive(is);
+        iarchive(savedGroups);
+    }
+    catch (cereal::Exception& e)
+    {
+        log<level::ERR>(e.what());
+        fs::remove(path);
+    }
+}
+
+} // namespace led
+} // namespace phosphor
diff --git a/serialize.hpp b/serialize.hpp
new file mode 100644
index 0000000..23cffa2
--- /dev/null
+++ b/serialize.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include <set>
+#include <string>
+
+namespace phosphor
+{
+namespace led
+{
+
+namespace fs = std::filesystem;
+
+// the set of names of asserted groups, which contains the D-Bus Object path
+using SavedGroups = std::set<std::string>;
+
+/** @class Serialize
+ *  @brief Store and restore groups of LEDs
+ */
+class Serialize
+{
+  public:
+    Serialize(const fs::path& path) : path(path)
+    {
+        restoreGroups();
+    }
+
+    /** @brief Store asserted group names to SAVED_GROUPS_FILE
+     *
+     *  @param [in] group     - name of the group
+     *  @param [in] asserted  - asserted state, true or false
+     */
+    void storeGroups(const std::string& group, bool asserted);
+
+    /** @brief Is the group in asserted state stored in SAVED_GROUPS_FILE
+     *
+     *  @param [in] objPath - The D-Bus path that hosts LED group
+     *
+     *  @return             - true: exist, false: does not exist
+     */
+    bool getGroupSavedState(const std::string& objPath) const;
+
+  private:
+    /** @brief restore asserted group names from SAVED_GROUPS_FILE
+     */
+    void restoreGroups();
+
+    /** @brief the set of names of asserted groups */
+    SavedGroups savedGroups;
+
+    /** @brief the path of file for storing the names of asserted groups */
+    fs::path path;
+};
+
+} // namespace led
+} // namespace phosphor
diff --git a/test/Makefile.am b/test/Makefile.am
index d4cd3bd..3941c5c 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -8,5 +8,5 @@
 utest_CPPFLAGS = -Igtest $(GTEST_CPPFLAGS) $(AM_CPPFLAGS) $(PHOSPHOR_LOGGING_CFLAGS)
 utest_CXXFLAGS = $(PTHREAD_CFLAGS)
 utest_LDFLAGS = -lgtest_main -lgtest $(PTHREAD_LIBS) $(OESDK_TESTCASE_FLAGS) $(SYSTEMD_LIBS) $(PHOSPHOR_LOGGING_LIBS) $(PHOSPHOR_DBUS_INTERFACES_LIBS)
-utest_SOURCES = utest.cpp utest-led-json.cpp
-utest_LDADD = $(top_builddir)/manager.o
+utest_SOURCES = utest.cpp utest-led-json.cpp utest-serialize.cpp
+utest_LDADD = $(top_builddir)/manager.o $(top_builddir)/serialize.o
diff --git a/test/utest-serialize.cpp b/test/utest-serialize.cpp
new file mode 100644
index 0000000..8c75031
--- /dev/null
+++ b/test/utest-serialize.cpp
@@ -0,0 +1,44 @@
+#include "serialize.hpp"
+
+#include <filesystem>
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::led;
+
+TEST(SerializeTest, testStoreGroups)
+{
+    namespace fs = std::filesystem;
+
+    static constexpr auto& path = "config/led-save-group.json";
+    static constexpr auto& bmcBooted =
+        "/xyz/openbmc_project/led/groups/bmc_booted";
+    static constexpr auto& powerOn = "/xyz/openbmc_project/led/groups/power_on";
+    static constexpr auto& enclosureIdentify =
+        "/xyz/openbmc_project/led/groups/EnclosureIdentify";
+
+    Serialize serialize(path);
+
+    serialize.storeGroups(bmcBooted, true);
+    ASSERT_EQ(true, serialize.getGroupSavedState(bmcBooted));
+
+    serialize.storeGroups(powerOn, true);
+    ASSERT_EQ(true, serialize.getGroupSavedState(powerOn));
+
+    serialize.storeGroups(bmcBooted, false);
+    ASSERT_EQ(false, serialize.getGroupSavedState(bmcBooted));
+
+    serialize.storeGroups(enclosureIdentify, true);
+    ASSERT_EQ(true, serialize.getGroupSavedState(enclosureIdentify));
+
+    Serialize newSerial(path);
+
+    ASSERT_EQ(true, newSerial.getGroupSavedState(powerOn));
+    ASSERT_EQ(true, newSerial.getGroupSavedState(enclosureIdentify));
+
+    newSerial.storeGroups(powerOn, false);
+    ASSERT_EQ(false, newSerial.getGroupSavedState(powerOn));
+
+    newSerial.storeGroups(enclosureIdentify, false);
+    ASSERT_EQ(false, newSerial.getGroupSavedState(enclosureIdentify));
+}