diff --git a/phosphor-ldap-config/ldap_config.cpp b/phosphor-ldap-config/ldap_config.cpp
index d10a711..cfa825c 100644
--- a/phosphor-ldap-config/ldap_config.cpp
+++ b/phosphor-ldap-config/ldap_config.cpp
@@ -20,6 +20,8 @@
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 namespace fs = std::filesystem;
 using Argument = xyz::openbmc_project::Common::InvalidArgument;
+using NotAllowed = sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
+using NotAllowedArgument = xyz::openbmc_project::Common::NotAllowed;
 
 using Line = std::string;
 using Key = std::string;
@@ -380,28 +382,8 @@
 
 ConfigIface::Type Config::lDAPType(ConfigIface::Type value)
 {
-    ConfigIface::Type val;
-    try
-    {
-        if (value == lDAPType())
-        {
-            return value;
-        }
-
-        val = ConfigIface::lDAPType(value);
-        writeConfig();
-        parent.startOrStopService(nslcdService, enabled());
-    }
-    catch (const InternalFailure& e)
-    {
-        throw;
-    }
-    catch (const std::exception& e)
-    {
-        log<level::ERR>(e.what());
-        elog<InternalFailure>();
-    }
-    return val;
+    elog<NotAllowed>(NotAllowedArgument::REASON("ReadOnly Property"));
+    return lDAPType();
 }
 
 bool Config::enabled(bool value)
diff --git a/phosphor-ldap-config/ldap_config_mgr.cpp b/phosphor-ldap-config/ldap_config_mgr.cpp
index 0a79ef2..a60e8f8 100644
--- a/phosphor-ldap-config/ldap_config_mgr.cpp
+++ b/phosphor-ldap-config/ldap_config_mgr.cpp
@@ -75,7 +75,8 @@
 
 void ConfigMgr::deleteObject()
 {
-    configPtr.reset(nullptr);
+    // TODO Not needed the delete functionality.
+    // will do in later commit
 }
 
 std::string ConfigMgr::createConfig(
@@ -125,173 +126,60 @@
                               Argument::ARGUMENT_VALUE(lDAPBaseDN.c_str()));
     }
 
-    // With current implementation we support only one LDAP server.
-    deleteObject();
+    // With current implementation we support only two default LDAP server.
+    // which will be always there but when the support comes for additional
+    // account providers then the create config would be used to create the
+    // additional config.
 
-    auto objPath = std::string(LDAP_CONFIG_DBUS_OBJ_PATH);
-    configPtr = std::make_unique<Config>(
-        bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
-        secureLDAP, lDAPServerURI, lDAPBindDN, lDAPBaseDN,
-        std::move(lDAPBindDNPassword),
-        static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
-        static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
-        userNameAttribute, *this);
+    std::string objPath;
 
+    if (static_cast<ConfigIface::Type>(lDAPType) == ConfigIface::Type::OpenLdap)
+    {
+        openLDAPConfigPtr.reset(nullptr);
+        objPath = openLDAPDbusObjectPath;
+        openLDAPConfigPtr = std::make_unique<Config>(
+            bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
+            secureLDAP, lDAPServerURI, lDAPBindDN, lDAPBaseDN,
+            std::move(lDAPBindDNPassword),
+            static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
+            static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
+            userNameAttribute, *this);
+    }
+    else
+    {
+        ADConfigPtr.reset(nullptr);
+        objPath = ADDbusObjectPath;
+        ADConfigPtr = std::make_unique<Config>(
+            bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
+            secureLDAP, lDAPServerURI, lDAPBindDN, lDAPBaseDN,
+            std::move(lDAPBindDNPassword),
+            static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
+            static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
+            userNameAttribute, *this);
+    }
     restartService(nscdService);
     return objPath;
 }
 
-void ConfigMgr::restore(const char* filePath)
+void ConfigMgr::createDefaultObjects()
 {
-    if (!fs::exists(filePath))
+    if (!openLDAPConfigPtr)
     {
-        log<level::ERR>("Config file doesn't exists",
-                        entry("LDAP_CONFIG_FILE=%s", configFilePath.c_str()));
-        return;
+        openLDAPConfigPtr = std::make_unique<Config>(
+            bus, openLDAPDbusObjectPath.c_str(), configFilePath.c_str(),
+            tlsCacertFile.c_str(), false, "", "", "", "",
+            ConfigIface::SearchScope::sub, ConfigIface::Type::OpenLdap, false,
+            "", "", *this);
     }
-
-    ConfigInfo configValues;
-    try
+    if (!ADConfigPtr)
     {
-        std::fstream stream(filePath, std::fstream::in);
-        Line line;
-        // read characters from stream and places them into line
-        while (std::getline(stream, line))
-        {
-            // remove leading and trailing extra spaces
-            auto firstScan = line.find_first_not_of(' ');
-            auto first =
-                (firstScan == std::string::npos ? line.length() : firstScan);
-            auto last = line.find_last_not_of(' ');
-            line = line.substr(first, last - first + 1);
-            // reduce multiple spaces between two words to a single space
-            auto pred = [](char a, char b) {
-                return (a == b && a == ' ') ? true : false;
-            };
-
-            auto lastPos = std::unique(line.begin(), line.end(), pred);
-
-            line.erase(lastPos, line.end());
-
-            // Ignore if line is empty or starts with '#'
-            if (line.empty() || line.at(0) == '#')
-            {
-                continue;
-            }
-
-            Key key;
-            std::istringstream isLine(line);
-            // extract characters from isLine and stores them into
-            // key until the delimitation character ' ' is found.
-            // If the delimiter is found, it is extracted and discarded
-            // the next input operation will begin after it.
-            if (std::getline(isLine, key, ' '))
-            {
-                Val value;
-                // extract characters after delimitation character ' '
-                if (std::getline(isLine, value, ' '))
-                {
-                    // skip line if it starts with "base shadow" or
-                    // "base passwd" because we would have 3 entries
-                    // ("base lDAPBaseDN" , "base passwd lDAPBaseDN" and
-                    // "base shadow lDAPBaseDN") for the property "lDAPBaseDN",
-                    // one is enough to restore it.
-
-                    if ((key == "base") &&
-                        (value == "passwd" || value == "shadow"))
-                    {
-                        continue;
-                    }
-
-                    // if config type is AD "map group" entry would be add to
-                    // the map configValues. For OpenLdap config file no map
-                    // entry would be there.
-                    if ((key == "map") && (value == "passwd"))
-                    {
-                        key = key + "_" + value;
-                        if (std::getline(isLine, value, ' '))
-                        {
-                            key += "_" + value;
-                        }
-                        std::getline(isLine, value, ' ');
-                    }
-                    configValues[key] = value;
-                }
-            }
-        }
-
-        CreateIface::SearchScope lDAPSearchScope;
-        if (configValues["scope"] == "sub")
-        {
-            lDAPSearchScope = CreateIface::SearchScope::sub;
-        }
-        else if (configValues["scope"] == "one")
-        {
-            lDAPSearchScope = CreateIface::SearchScope::one;
-        }
-        else
-        {
-            lDAPSearchScope = CreateIface::SearchScope::base;
-        }
-
-        CreateIface::Type lDAPType;
-        // If the file is having a line which starts with "map group"
-        if (configValues["map"] == "group")
-        {
-            lDAPType = CreateIface::Type::ActiveDirectory;
-        }
-        else
-        {
-            lDAPType = CreateIface::Type::OpenLdap;
-        }
-
-        // Don't create the config object if either of the field is empty.
-        if (configValues["uri"] == "" || configValues["binddn"] == "" ||
-            configValues["base"] == "")
-        {
-            log<level::INFO>(
-                "LDAP config parameter value missing",
-                entry("URI=%s", configValues["uri"].c_str()),
-                entry("BASEDN=%s", configValues["base"].c_str()),
-                entry("BINDDN=%s", configValues["binddn"].c_str()));
-            return;
-        }
-
-        createConfig(std::move(configValues["uri"]),
-                     std::move(configValues["binddn"]),
-                     std::move(configValues["base"]),
-                     std::move(configValues["bindpw"]), lDAPSearchScope,
-                     lDAPType, std::move(configValues["map_passwd_uid"]),
-                     std::move(configValues["map_passwd_gidNumber"]));
-
-        // Get the enabled property value from the persistent location
-        if (!deserialize(dbusPersistentPath, *configPtr))
-        {
-            log<level::INFO>(
-                "Deserialization Failed, continue with service disable");
-        }
-    }
-    catch (const InvalidArgument& e)
-    {
-        // Don't throw - we don't want to create a D-Bus
-        // object upon finding empty values in config, as
-        // this can be a default config.
-    }
-    catch (const NoCACertificate& e)
-    {
-        // Don't throw - we don't want to create a D-Bus
-        // object upon finding "ssl on" without having tls_cacertFile in place,
-        // as this can be a default config.
-    }
-    catch (const InternalFailure& e)
-    {
-        throw;
-    }
-    catch (const std::exception& e)
-    {
-        log<level::ERR>(e.what());
-        elog<InternalFailure>();
+        ADConfigPtr = std::make_unique<Config>(
+            bus, ADDbusObjectPath.c_str(), configFilePath.c_str(),
+            tlsCacertFile.c_str(), false, "", "", "", "",
+            ConfigIface::SearchScope::sub, ConfigIface::Type::ActiveDirectory,
+            false, "", "", *this);
     }
 }
+
 } // namespace ldap
 } // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_config_mgr.hpp b/phosphor-ldap-config/ldap_config_mgr.hpp
index b30d98c..a3895ae 100644
--- a/phosphor-ldap-config/ldap_config_mgr.hpp
+++ b/phosphor-ldap-config/ldap_config_mgr.hpp
@@ -18,6 +18,10 @@
 
 static constexpr auto defaultNslcdFile = "nslcd.conf.default";
 static constexpr auto nsSwitchFile = "nsswitch.conf";
+static auto openLDAPDbusObjectPath =
+    std::string(LDAP_CONFIG_ROOT) + "/openldap";
+static auto ADDbusObjectPath =
+    std::string(LDAP_CONFIG_ROOT) + "/active_directory";
 
 using namespace phosphor::logging;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
@@ -53,17 +57,6 @@
         dbusPersistentPath(dbusPersistentPath), configFilePath(filePath),
         bus(bus)
     {
-        try
-        {
-            restore(configFilePath.c_str());
-            emit_object_added();
-        }
-        catch (const std::exception& e)
-        {
-            configPtr.reset(nullptr);
-            log<level::ERR>(e.what());
-            elog<InternalFailure>();
-        }
     }
 
     /** @brief concrete implementation of the pure virtual funtion
@@ -110,6 +103,10 @@
      */
     void deleteObject();
 
+    /* Create the default active directory and the openldap config
+     * objects. */
+    virtual void createDefaultObjects();
+
     /* ldap service enabled property would be saved under
      * this path.
      */
@@ -122,13 +119,17 @@
     /** @brief Persistent sdbusplus D-Bus bus connection. */
     sdbusplus::bus::bus& bus;
 
-    /** @brief Pointer to a Config D-Bus object */
-    std::unique_ptr<Config> configPtr = nullptr;
+    /* Below two config objects are default, which will always be there */
 
-    /** @brief Populate existing config into D-Bus properties
-     *  @param[in] filePath - LDAP config file path
-     */
-    virtual void restore(const char* filePath);
+    /* if need arises then we can have below map for additional account
+     * providers we need to create sub class of Config which will implement the
+     * delete interface as the default objects will not implement the delete
+     * std::map<std::string, std::unique_ptr<NewConfig>> AdditionalProviders*/
+
+    /** @brief Pointer to a openLDAP Config D-Bus object */
+    std::unique_ptr<Config> openLDAPConfigPtr = nullptr;
+    /** @brief Pointer to a AD Config D-Bus object */
+    std::unique_ptr<Config> ADConfigPtr = nullptr;
 };
 } // namespace ldap
 } // namespace phosphor
diff --git a/phosphor-ldap-config/main.cpp b/phosphor-ldap-config/main.cpp
index c6eaa5a..e0ac638 100644
--- a/phosphor-ldap-config/main.cpp
+++ b/phosphor-ldap-config/main.cpp
@@ -27,6 +27,7 @@
 
     phosphor::ldap::ConfigMgr mgr(bus, LDAP_CONFIG_ROOT, LDAP_CONFIG_FILE,
                                   LDAP_CONF_PERSIST_PATH, TLS_CACERT_FILE);
+    mgr.createDefaultObjects();
 
     bus.request_name(LDAP_CONFIG_BUSNAME);