diff --git a/pldmd/oem_ibm.hpp b/pldmd/oem_ibm.hpp
new file mode 100644
index 0000000..82f3699
--- /dev/null
+++ b/pldmd/oem_ibm.hpp
@@ -0,0 +1,182 @@
+#pragma once
+
+#include "libpldm/pdr.h"
+
+#include "../oem/ibm/libpldmresponder/file_io.hpp"
+#include "../oem/ibm/libpldmresponder/fru_oem_ibm.hpp"
+#include "../oem/ibm/libpldmresponder/oem_ibm_handler.hpp"
+#include "common/utils.hpp"
+#include "dbus_impl_requester.hpp"
+#include "host-bmc/dbus_to_event_handler.hpp"
+#include "invoker.hpp"
+#include "libpldmresponder/fru.hpp"
+#include "requester/request.hpp"
+
+namespace pldm
+{
+namespace oem_ibm
+{
+
+using namespace pldm::state_sensor;
+using namespace pldm::dbus_api;
+
+/**
+ * @class OemIBM
+ *
+ * @brief class for creating all the OEM IBM handlers
+ *
+ *  Only in case of OEM_IBM this class object will be instantiated
+ */
+class OemIBM
+{
+  public:
+    OemIBM() = delete;
+    OemIBM(const Pdr&) = delete;
+    OemIBM& operator=(const OemIBM&) = delete;
+    OemIBM(OemIBM&&) = delete;
+    OemIBM& operator=(OemIBM&&) = delete;
+
+  public:
+    /** Constructs OemIBM object
+     *
+     * @param[in] dBusIntf - D-Bus handler
+     * @param[in] mctp_fd - fd of MCTP communications socket
+     * @param[in] mctp_eid - MCTP EID of remote host firmware
+     * @param[in] repo - pointer to BMC's primary PDR repo
+     * @param[in] instanceIdDb - pointer to an InstanceIdDb object
+     * @param[in] event - sd_event handler
+     * @param[in] invoker - invoker handler
+     * @param[in] hostPDRHandler - hostPDRHandler handler
+     * @param[in] platformHandler - platformHandler handler
+     * @param[in] fruHandler - fruHandler handler
+     * @param[in] baseHandler - baseHandler handler
+     * @param[in] reqHandler - reqHandler handler
+     */
+    explicit OemIBM(
+        const pldm::utils::DBusHandler* dBusIntf, int mctp_fd, uint8_t mctp_eid,
+        pldm_pdr* repo, pldm::InstanceIdDb& instanceIdDb,
+        sdeventplus::Event& event, Invoker& invoker,
+        HostPDRHandler* hostPDRHandler, platform::Handler* platformHandler,
+        fru::Handler* fruHandler, base::Handler* baseHandler,
+        pldm::requester::Handler<pldm::requester::Request>* reqHandler) :
+        dBusIntf(dBusIntf),
+        mctp_fd(mctp_fd), mctp_eid(mctp_eid), repo(repo),
+        instanceIdDb(instanceIdDb), event(event), invoker(invoker),
+        reqHandler(reqHandler)
+    {
+        createOemFruHandler();
+        fruHandler->setOemFruHandler(oemFruHandler.get());
+
+        createOemIbmFruHandler();
+        oemIbmFruHandler->setIBMFruHandler(fruHandler);
+
+        createCodeUpdate();
+        createOemPlatformHandler();
+        codeUpdate->setOemPlatformHandler(oemPlatformHandler.get());
+        hostPDRHandler->setOemPlatformHandler(oemPlatformHandler.get());
+        platformHandler->setOemPlatformHandler(oemPlatformHandler.get());
+        baseHandler->setOemPlatformHandler(oemPlatformHandler.get());
+
+        createOemIbmPlatformHandler();
+        oemIbmPlatformHandler->setPlatformHandler(platformHandler);
+
+        registerHandler();
+    }
+
+  private:
+    /** @brief Method for creating codeUpdate handler */
+    void createCodeUpdate()
+    {
+        codeUpdate = std::make_unique<pldm::responder::CodeUpdate>(dBusIntf);
+        codeUpdate->clearDirPath(LID_STAGING_DIR);
+    }
+
+    /** @brief Method for creating oemPlatformHandler
+     *
+     *  This method also assigns the oemPlatformHandler to the below
+     *  different handlers.
+     */
+    void createOemPlatformHandler()
+    {
+        oemPlatformHandler = std::make_unique<oem_ibm_platform::Handler>(
+            dBusIntf, codeUpdate.get(), mctp_fd, mctp_eid, instanceIdDb, event,
+            reqHandler);
+    }
+
+    /** @brief Method for creating oemIbmPlatformHandler */
+    void createOemIbmPlatformHandler()
+    {
+        oemIbmPlatformHandler =
+            dynamic_cast<pldm::responder::oem_ibm_platform::Handler*>(
+                oemPlatformHandler.get());
+    }
+
+    /** @brief Method for creating oemFruHandler */
+    void createOemFruHandler()
+    {
+        oemFruHandler = std::make_unique<oem_ibm_fru::Handler>(repo);
+    }
+
+    /** @brief Method for creating oemIbmFruHandler */
+    void createOemIbmFruHandler()
+    {
+        oemIbmFruHandler = dynamic_cast<pldm::responder::oem_ibm_fru::Handler*>(
+            oemFruHandler.get());
+    }
+
+    /** @brief Method for registering PLDM OEM handler */
+    void registerHandler()
+    {
+        invoker.registerHandler(
+            PLDM_OEM, std::make_unique<pldm::responder::oem_ibm::Handler>(
+                          oemPlatformHandler.get(), mctp_fd, mctp_eid,
+                          &instanceIdDb, reqHandler));
+    }
+
+  private:
+    /** @brief D-Bus handler */
+    const pldm::utils::DBusHandler* dBusIntf;
+
+    /** @brief fd of MCTP communications socket */
+    int mctp_fd;
+
+    /** @brief MCTP EID of remote host firmware */
+    uint8_t mctp_eid;
+
+    /** @brief pointer to BMC's primary PDR repo */
+    pldm_pdr* repo;
+
+    /** @brief reference to an Instance ID database object, used to obtain PLDM
+     * instance IDs
+     */
+    pldm::InstanceIdDb& instanceIdDb;
+
+    /** @brief reference of main event loop of pldmd, primarily used to schedule
+     *  work
+     */
+    sdeventplus::Event& event;
+
+    /** @brief Object to the invoker class*/
+    Invoker& invoker;
+
+    /** @brief pointer to the requester class*/
+    requester::Handler<requester::Request>* reqHandler;
+
+    /** @brief pointer to the oem_ibm_handler class*/
+    std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
+
+    /** @brief pointer to the oem_ibm_fru class*/
+    std::unique_ptr<oem_fru::Handler> oemFruHandler{};
+
+    /** @brief pointer to the CodeUpdate class*/
+    std::unique_ptr<pldm::responder::CodeUpdate> codeUpdate{};
+
+    /** @brief oem IBM Platform handler*/
+    pldm::responder::oem_ibm_platform::Handler* oemIbmPlatformHandler = nullptr;
+
+    /** @brief oem IBM Fru handler*/
+    pldm::responder::oem_ibm_fru::Handler* oemIbmFruHandler = nullptr;
+};
+
+} // namespace oem_ibm
+} // namespace pldm
diff --git a/pldmd/pldmd.cpp b/pldmd/pldmd.cpp
index 1030c8e..102458f 100644
--- a/pldmd/pldmd.cpp
+++ b/pldmd/pldmd.cpp
@@ -60,9 +60,7 @@
 #endif
 
 #ifdef OEM_IBM
-#include "libpldmresponder/file_io.hpp"
-#include "libpldmresponder/fru_oem_ibm.hpp"
-#include "libpldmresponder/oem_ibm_handler.hpp"
+#include "oem_ibm.hpp"
 #endif
 
 constexpr uint8_t MCTP_MSG_TYPE_PLDM = 1;
@@ -232,31 +230,16 @@
         hostEffecterParser;
     std::unique_ptr<DbusToPLDMEvent> dbusToPLDMEventHandler;
     DBusHandler dbusHandler;
-    std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     std::unique_ptr<platform_config::Handler> platformConfigHandler{};
     platformConfigHandler = std::make_unique<platform_config::Handler>();
-    std::unique_ptr<oem_fru::Handler> oemFruHandler{};
 
-#ifdef OEM_IBM
-    std::unique_ptr<pldm::responder::CodeUpdate> codeUpdate =
-        std::make_unique<pldm::responder::CodeUpdate>(&dbusHandler);
-    codeUpdate->clearDirPath(LID_STAGING_DIR);
-    oemPlatformHandler = std::make_unique<oem_ibm_platform::Handler>(
-        &dbusHandler, codeUpdate.get(), pldmTransport.getEventSource(), hostEID,
-        instanceIdDb, event, &reqHandler);
-    codeUpdate->setOemPlatformHandler(oemPlatformHandler.get());
-    oemFruHandler = std::make_unique<oem_ibm_fru::Handler>(pdrRepo.get());
-    invoker.registerHandler(PLDM_OEM, std::make_unique<oem_ibm::Handler>(
-                                          oemPlatformHandler.get(),
-                                          pldmTransport.getEventSource(),
-                                          hostEID, &instanceIdDb, &reqHandler));
-#endif
     if (hostEID)
     {
         hostPDRHandler = std::make_shared<HostPDRHandler>(
             pldmTransport.getEventSource(), hostEID, event, pdrRepo.get(),
             EVENTS_JSONS_DIR, entityTree.get(), bmcEntityTree.get(),
-            instanceIdDb, &reqHandler, oemPlatformHandler.get());
+            instanceIdDb, &reqHandler);
+
         // HostFirmware interface needs access to hostPDR to know if host
         // is running
         dbusImplHost.setHostPdrObj(hostPDRHandler);
@@ -268,13 +251,10 @@
         dbusToPLDMEventHandler = std::make_unique<DbusToPLDMEvent>(
             pldmTransport.getEventSource(), hostEID, instanceIdDb, &reqHandler);
     }
-    auto biosHandler = std::make_unique<bios::Handler>(
-        pldmTransport.getEventSource(), hostEID, &instanceIdDb, &reqHandler,
-        platformConfigHandler.get(), requestPLDMServiceName);
 
     auto fruHandler = std::make_unique<fru::Handler>(
         FRU_JSONS_DIR, FRU_MASTER_JSON, pdrRepo.get(), entityTree.get(),
-        bmcEntityTree.get(), oemFruHandler.get());
+        bmcEntityTree.get());
 
     // FRU table is built lazily when a FRU command or Get PDR command is
     // handled. To enable building FRU table, the FRU handler is passed to the
@@ -282,25 +262,27 @@
     auto platformHandler = std::make_unique<platform::Handler>(
         &dbusHandler, hostEID, &instanceIdDb, PDR_JSONS_DIR, pdrRepo.get(),
         hostPDRHandler.get(), dbusToPLDMEventHandler.get(), fruHandler.get(),
-        oemPlatformHandler.get(), platformConfigHandler.get(), &reqHandler,
-        event, true);
-#ifdef OEM_IBM
-    pldm::responder::oem_ibm_platform::Handler* oemIbmPlatformHandler =
-        dynamic_cast<pldm::responder::oem_ibm_platform::Handler*>(
-            oemPlatformHandler.get());
-    oemIbmPlatformHandler->setPlatformHandler(platformHandler.get());
+        platformConfigHandler.get(), &reqHandler, event, true);
 
-    pldm::responder::oem_ibm_fru::Handler* oemIbmFruHandler =
-        dynamic_cast<pldm::responder::oem_ibm_fru::Handler*>(
-            oemFruHandler.get());
-    oemIbmFruHandler->setIBMFruHandler(fruHandler.get());
+    auto biosHandler = std::make_unique<bios::Handler>(
+        pldmTransport.getEventSource(), hostEID, &instanceIdDb, &reqHandler,
+        platformConfigHandler.get(), requestPLDMServiceName);
+
+    auto baseHandler = std::make_unique<base::Handler>(event);
+
+#ifdef OEM_IBM
+    pldm::oem_ibm::OemIBM oemIBM(&dbusHandler, pldmTransport.getEventSource(),
+                                 hostEID, pdrRepo.get(), instanceIdDb, event,
+                                 invoker, hostPDRHandler.get(),
+                                 platformHandler.get(), fruHandler.get(),
+                                 baseHandler.get(), &reqHandler);
 #endif
 
     invoker.registerHandler(PLDM_BIOS, std::move(biosHandler));
     invoker.registerHandler(PLDM_PLATFORM, std::move(platformHandler));
-    invoker.registerHandler(PLDM_BASE, std::make_unique<base::Handler>(
-                                           event, oemPlatformHandler.get()));
     invoker.registerHandler(PLDM_FRU, std::move(fruHandler));
+    invoker.registerHandler(PLDM_BASE, std::move(baseHandler));
+
     dbus_api::Pdr dbusImplPdr(bus, "/xyz/openbmc_project/pldm", pdrRepo.get());
     sdbusplus::xyz::openbmc_project::PLDM::server::Event dbusImplEvent(
         bus, "/xyz/openbmc_project/pldm");