diff --git a/phosphor-ldap-config/ldap_mapper_entry.cpp b/phosphor-ldap-config/ldap_mapper_entry.cpp
new file mode 100644
index 0000000..8410942
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_entry.cpp
@@ -0,0 +1,76 @@
+#include <experimental/filesystem>
+#include <xyz/openbmc_project/Common/error.hpp>
+#include <xyz/openbmc_project/User/Common/error.hpp>
+#include <phosphor-logging/log.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/elog-errors.hpp>
+#include "config.h"
+#include "ldap_mapper_entry.hpp"
+#include "ldap_mapper_mgr.hpp"
+#include "ldap_mapper_serialize.hpp"
+
+namespace phosphor
+{
+namespace user
+{
+
+using namespace phosphor::logging;
+using InvalidArgument =
+    sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
+using Argument = xyz::openbmc_project::Common::InvalidArgument;
+
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+                                 const char *filePath,
+                                 const std::string &groupName,
+                                 const std::string &privilege,
+                                 LDAPMapperMgr &parent) :
+    Ifaces(bus, path, true),
+    id(std::stol(std::experimental::filesystem::path(path).filename())),
+    manager(parent), persistPath(filePath)
+{
+    Ifaces::privilege(privilege, true);
+    Ifaces::groupName(groupName, true);
+    Ifaces::emit_object_added();
+}
+
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+                                 const char *filePath, LDAPMapperMgr &parent) :
+    Ifaces(bus, path, true),
+    id(std::stol(std::experimental::filesystem::path(path).filename())),
+    manager(parent), persistPath(filePath)
+{
+}
+
+void LDAPMapperEntry::delete_(void)
+{
+    manager.deletePrivilegeMapper(id);
+}
+
+std::string LDAPMapperEntry::groupName(std::string value)
+{
+    if (value == Ifaces::groupName())
+    {
+        return value;
+    }
+
+    manager.checkPrivilegeMapper(value);
+    auto val = Ifaces::groupName(value);
+    serialize(*this, id, persistPath);
+    return val;
+}
+
+std::string LDAPMapperEntry::privilege(std::string value)
+{
+    if (value == Ifaces::privilege())
+    {
+        return value;
+    }
+
+    manager.checkPrivilegeLevel(value);
+    auto val = Ifaces::privilege(value);
+    serialize(*this, id, persistPath);
+    return val;
+}
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_entry.hpp b/phosphor-ldap-config/ldap_mapper_entry.hpp
new file mode 100644
index 0000000..dea85c2
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_entry.hpp
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server/object.hpp>
+#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
+#include <xyz/openbmc_project/Object/Delete/server.hpp>
+
+namespace phosphor
+{
+namespace user
+{
+
+namespace Base = sdbusplus::xyz::openbmc_project;
+using Entry =
+    sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry;
+using Delete = sdbusplus::xyz::openbmc_project::Object::server::Delete;
+using Ifaces = sdbusplus::server::object::object<Entry, Delete>;
+
+// Forward declaration for LDAPMapperMgr
+class LDAPMapperMgr;
+
+using Id = size_t;
+
+/** @class LDAPMapperEntry
+ *
+ *  @brief This D-Bus object represents the privilege level for the LDAP group.
+ */
+class LDAPMapperEntry : public Ifaces
+{
+  public:
+    LDAPMapperEntry() = delete;
+    ~LDAPMapperEntry() = default;
+    LDAPMapperEntry(const LDAPMapperEntry &) = delete;
+    LDAPMapperEntry &operator=(const LDAPMapperEntry &) = delete;
+    LDAPMapperEntry(LDAPMapperEntry &&) = default;
+    LDAPMapperEntry &operator=(LDAPMapperEntry &&) = default;
+
+    /** @brief Constructs LDAP privilege mapper entry object.
+     *
+     *  @param[in] bus  - sdbusplus handler
+     *  @param[in] path - D-Bus path
+     *  @param[in] filePath - serialization directory path
+     *  @param[in] groupName - LDAP group name
+     *  @param[in] privilege - the privilege for the group
+     *  @param[in] parent - LDAP privilege mapper manager
+     */
+    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+                    const char *filePath, const std::string &groupName,
+                    const std::string &privilege, LDAPMapperMgr &parent);
+
+    /** @brief Constructs LDAP privilege mapper entry object
+     *
+     *  @param[in] bus  - sdbusplus handler
+     *  @param[in] path - D-Bus path
+     *  @param[in] filePath - serialization directory path
+     *  @param[in] parent - LDAP privilege mapper manager
+     */
+    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+                    const char *filePath, LDAPMapperMgr &parent);
+
+    /** @brief Delete privilege mapper entry object
+     *
+     *  This method deletes the privilege mapper entry.
+     */
+    void delete_(void) override;
+
+    /** @brief Update the group name of the mapper object
+     *
+     *  @param[in] value - group name
+     *
+     *  @return On success the updated group name
+     */
+    std::string groupName(std::string value) override;
+
+    /** @brief Update privilege associated with LDAP group
+     *
+     *  @param[in] value - privilege level
+     *
+     *  @return On success the updated privilege level
+     */
+    std::string privilege(std::string value) override;
+
+    using sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+        privilege;
+
+    using sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+        groupName;
+
+  private:
+    Id id;
+    LDAPMapperMgr &manager;
+
+    /** @brief serialization directory path */
+    std::string persistPath;
+};
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.cpp b/phosphor-ldap-config/ldap_mapper_serialize.cpp
new file mode 100644
index 0000000..3ef809e
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_serialize.cpp
@@ -0,0 +1,94 @@
+#include <cereal/archives/binary.hpp>
+#include <cereal/types/string.hpp>
+#include <fstream>
+#include <phosphor-logging/log.hpp>
+#include "config.h"
+#include "ldap_mapper_serialize.hpp"
+
+// Register class version
+// From cereal documentation;
+// "This macro should be placed at global scope"
+CEREAL_CLASS_VERSION(phosphor::user::LDAPMapperEntry, CLASS_VERSION);
+
+namespace phosphor
+{
+namespace user
+{
+
+using namespace phosphor::logging;
+
+/** @brief Function required by Cereal to perform serialization.
+ *
+ *  @tparam Archive - Cereal archive type (binary in this case).
+ *  @param[in] archive - reference to cereal archive.
+ *  @param[in] entry- const reference to LDAP mapper entry
+ *  @param[in] version - Class version that enables handling a serialized data
+ *                       across code levels
+ */
+template <class Archive>
+void save(Archive& archive, const LDAPMapperEntry& entry,
+          const std::uint32_t version)
+{
+    archive(entry.groupName(), entry.privilege());
+}
+
+/** @brief Function required by Cereal to perform deserialization.
+ *
+ *  @tparam Archive - Cereal archive type (binary in our case).
+ *  @param[in] archive - reference to cereal archive.
+ *  @param[out] entry - LDAP mapper entry to be read
+ *  @param[in] version - Class version that enables handling a serialized data
+ *                       across code levels
+ */
+template <class Archive>
+void load(Archive& archive, LDAPMapperEntry& entry, const std::uint32_t version)
+{
+    std::string groupName{};
+    std::string privilege{};
+
+    archive(groupName, privilege);
+
+    entry.sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+        groupName(groupName, true);
+    entry.sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+        privilege(privilege, true);
+}
+
+fs::path serialize(const LDAPMapperEntry& entry, Id id, const fs::path& dir)
+{
+    auto path = dir / std::to_string(id);
+    std::ofstream os(path.c_str(), std::ios::binary);
+    cereal::BinaryOutputArchive oarchive(os);
+    oarchive(entry);
+    return path;
+}
+
+bool deserialize(const fs::path& path, LDAPMapperEntry& entry)
+{
+    try
+    {
+        if (fs::exists(path))
+        {
+            std::ifstream is(path.c_str(), std::ios::in | std::ios::binary);
+            cereal::BinaryInputArchive iarchive(is);
+            iarchive(entry);
+            return true;
+        }
+        return false;
+    }
+    catch (cereal::Exception& e)
+    {
+        log<level::ERR>(e.what());
+        fs::remove(path);
+        return false;
+    }
+    catch (const std::length_error& e)
+    {
+        log<level::ERR>(e.what());
+        fs::remove(path);
+        return false;
+    }
+}
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.hpp b/phosphor-ldap-config/ldap_mapper_serialize.hpp
new file mode 100644
index 0000000..5ab71c0
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_serialize.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <experimental/filesystem>
+#include "config.h"
+#include "ldap_mapper_entry.hpp"
+
+namespace phosphor
+{
+namespace user
+{
+
+namespace fs = std::experimental::filesystem;
+
+/** @brief Serialize and persist LDAP privilege mapper D-Bus object
+ *
+ *  @param[in] entry - LDAP privilege mapper entry
+ *  @param[in] id - filename of the persisted LDAP mapper entry
+ *  @param[in] dir - pathname of directory where the serialized privilege
+ *                   mappings are stored.
+ *
+ *  @return fs::path - pathname of persisted error file
+ */
+fs::path serialize(const LDAPMapperEntry& entry, Id id, const fs::path& dir);
+
+/** @brief Deserialize a persisted LDAP privilege mapper into a D-Bus object
+ *
+ *  @param[in] path - pathname of persisted file
+ *  @param[in/out] entry - reference to  LDAP privilege mapper entry object
+ *                         which is the target of deserialization.
+ *
+ *  @return bool - true if the deserialization was successful, false otherwise.
+ */
+bool deserialize(const fs::path& path, LDAPMapperEntry& entry);
+
+} // namespace user
+} // namespace phosphor