diff --git a/certificate.cpp b/certificate.cpp
index af8635e..b36e5f4 100644
--- a/certificate.cpp
+++ b/certificate.cpp
@@ -1,3 +1,5 @@
+#include "config.h"
+
 #include "certificate.hpp"
 
 #include <openssl/bio.h>
@@ -88,7 +90,18 @@
     typeFuncMap[SERVER] = installHelper;
     typeFuncMap[CLIENT] = installHelper;
     typeFuncMap[AUTHORITY] = [](auto filePath) {};
+
+    auto appendPrivateKey = [this](const std::string& filePath) {
+        checkAndAppendPrivateKey(filePath);
+    };
+
+    appendKeyMap[SERVER] = appendPrivateKey;
+    appendKeyMap[CLIENT] = appendPrivateKey;
+    appendKeyMap[AUTHORITY] = [](const std::string& filePath) {};
+
+    // install the certificate
     install(uploadPath, isSkipUnitReload);
+
     this->emit_object_added();
 }
 
@@ -237,14 +250,23 @@
         elog<InvalidCertificate>(Reason("Certificate validation failed"));
     }
 
-    // Invoke type specific compare keys function.
-    auto iter = typeFuncMap.find(certType);
-    if (iter == typeFuncMap.end())
+    // Invoke type specific append private key function.
+    auto appendIter = appendKeyMap.find(certType);
+    if (appendIter == appendKeyMap.end())
     {
         log<level::ERR>("Unsupported Type", entry("TYPE=%s", certType.c_str()));
         elog<InternalFailure>();
     }
-    iter->second(filePath);
+    appendIter->second(filePath);
+
+    // Invoke type specific compare keys function.
+    auto compIter = typeFuncMap.find(certType);
+    if (compIter == typeFuncMap.end())
+    {
+        log<level::ERR>("Unsupported Type", entry("TYPE=%s", certType.c_str()));
+        elog<InternalFailure>();
+    }
+    compIter->second(filePath);
 
     // Copy the certificate to the installation path
     // During bootup will be parsing existing file so no need to
@@ -406,6 +428,61 @@
     }
     return cert;
 }
+
+void Certificate::checkAndAppendPrivateKey(const std::string& filePath)
+{
+    BIO_MEM_Ptr keyBio(BIO_new(BIO_s_file()), ::BIO_free);
+    if (!keyBio)
+    {
+        log<level::ERR>("Error occured during BIO_s_file call",
+                        entry("FILE=%s", filePath.c_str()));
+        elog<InternalFailure>();
+    }
+    BIO_read_filename(keyBio.get(), filePath.c_str());
+
+    EVP_PKEY_Ptr priKey(
+        PEM_read_bio_PrivateKey(keyBio.get(), nullptr, nullptr, nullptr),
+        ::EVP_PKEY_free);
+    if (!priKey)
+    {
+        log<level::INFO>("Private key not present in file",
+                         entry("FILE=%s", filePath.c_str()));
+        fs::path privateKeyFile = fs::path(certInstallPath).parent_path();
+        privateKeyFile = privateKeyFile / PRIV_KEY_FILE_NAME;
+        if (!fs::exists(privateKeyFile))
+        {
+            log<level::ERR>("Private key file is not found",
+                            entry("FILE=%s", privateKeyFile.c_str()));
+            elog<InternalFailure>();
+        }
+
+        std::ifstream privKeyFileStream;
+        std::ofstream certFileStream;
+        privKeyFileStream.exceptions(std::ifstream::failbit |
+                                     std::ifstream::badbit |
+                                     std::ifstream::eofbit);
+        certFileStream.exceptions(std::ofstream::failbit |
+                                  std::ofstream::badbit |
+                                  std::ofstream::eofbit);
+        try
+        {
+            privKeyFileStream.open(privateKeyFile);
+            certFileStream.open(filePath, std::ios::app);
+            certFileStream << privKeyFileStream.rdbuf() << std::flush;
+            privKeyFileStream.close();
+            certFileStream.close();
+        }
+        catch (const std::exception& e)
+        {
+            log<level::ERR>("Failed to append private key",
+                            entry("ERR=%s", e.what()),
+                            entry("SRC=%s", privateKeyFile.c_str()),
+                            entry("DST=%s", filePath.c_str()));
+            elog<InternalFailure>();
+        }
+    }
+}
+
 bool Certificate::compareKeys(const std::string& filePath)
 {
     log<level::INFO>("Certificate compareKeys",
diff --git a/certificate.hpp b/certificate.hpp
index 70ee522..aea3ce6 100644
--- a/certificate.hpp
+++ b/certificate.hpp
@@ -25,6 +25,7 @@
 using CertUploadPath = std::string;
 using InputType = std::string;
 using InstallFunc = std::function<void(const std::string&)>;
+using AppendPrivKeyFunc = std::function<void(const std::string&)>;
 using CertWatchPtr = std::unique_ptr<Watch>;
 using namespace phosphor::logging;
 
@@ -92,19 +93,28 @@
     void install(const std::string& filePath, bool isSkipUnitReload);
 
     /** @brief Load Certificate file into the X509 structre.
-     *  @param[in] fileName - Certificate and key full file path.
+     *  @param[in] filePath - Certificate and key full file path.
      *  @return pointer to the X509 structure.
      */
     X509_Ptr loadCert(const std::string& filePath);
 
+    /** @brief Check and append private key to the certificate file
+     *         If private key is not present in the certificate file append the
+     *         certificate file with private key existing in the system.
+     *  @param[in] filePath - Certificate and key full file path.
+     *  @return void.
+     */
+    void checkAndAppendPrivateKey(const std::string& filePath);
+
     /** @brief Public/Private key compare function.
      *         Comparing private key against certificate public key
      *         from input .pem file.
-     *  @param[in] fileName - Certificate and key full file path.
+     *  @param[in] filePath - Certificate and key full file path.
      *  @return Return true if Key compare is successful,
      *          false if not
      */
     bool compareKeys(const std::string& filePath);
+
     /** @brief systemd unit reload or reset helper function
      *  Reload if the unit supports it and use a restart otherwise.
      *  @param[in] unit - service need to reload.
@@ -129,6 +139,9 @@
     /** @brief Certificate file installation path **/
     CertInstallPath certInstallPath;
 
+    /** @brief Type specific function pointer map for appending private key */
+    std::unordered_map<InputType, AppendPrivKeyFunc> appendKeyMap;
+
     /** @brief Certificate file create/update watch */
     const CertWatchPtr& certWatchPtr;
 };
diff --git a/test/certs_manager_test.cpp b/test/certs_manager_test.cpp
index d596234..6e7f878 100644
--- a/test/certs_manager_test.cpp
+++ b/test/certs_manager_test.cpp
@@ -423,12 +423,12 @@
                 MainApp mainApp(&manager);
                 mainApp.install(certificateFile);
             }
-            catch (const InvalidCertificate& e)
+            catch (const InternalFailure& e)
             {
                 throw;
             }
         },
-        InvalidCertificate);
+        InternalFailure);
     EXPECT_FALSE(fs::exists(verifyPath));
 }
 
@@ -455,7 +455,7 @@
                 MainApp mainApp(&manager);
                 mainApp.install(keyFile);
             }
-            catch (const InvalidCertificate& e)
+            catch (const InternalFailure& e)
             {
                 throw;
             }