diff --git a/extensions/openpower-pels/pldm_interface.cpp b/extensions/openpower-pels/pldm_interface.cpp
index 87edb1c..8fa7c18 100644
--- a/extensions/openpower-pels/pldm_interface.cpp
+++ b/extensions/openpower-pels/pldm_interface.cpp
@@ -17,6 +17,7 @@
 
 #include <libpldm/base.h>
 #include <libpldm/file_io.h>
+#include <systemd/sd-bus.h>
 #include <unistd.h>
 
 #include <fstream>
@@ -25,6 +26,21 @@
 namespace openpower::pels
 {
 
+namespace service
+{
+constexpr auto pldm = "xyz.openbmc_project.PLDM";
+}
+
+namespace object_path
+{
+constexpr auto pldm = "/xyz/openbmc_project/pldm";
+}
+
+namespace interface
+{
+constexpr auto pldm_requester = "xyz.openbmc_project.PLDM.Requester";
+}
+
 using namespace phosphor::logging;
 using namespace sdeventplus;
 using namespace sdeventplus::source;
@@ -36,6 +52,7 @@
 
 PLDMInterface::~PLDMInterface()
 {
+    sd_bus_unref(_bus);
     closeFD();
 }
 
@@ -84,7 +101,60 @@
     }
 }
 
-CmdStatus PLDMInterface::sendNewLogCmd(uint32_t id, uint32_t size)
+void PLDMInterface::instanceIDCallback(sd_bus_message* msg)
+{
+    if (!_inProgress)
+    {
+        // A cancelCmd was run, just return
+        log<level::INFO>(
+            "A command was canceled while waiting for the instance ID");
+        return;
+    }
+
+    bool failed = false;
+
+    auto rc = sd_bus_message_get_errno(msg);
+    if (rc)
+    {
+        log<level::ERR>("GetInstanceId D-Bus method failed",
+                        entry("ERRNO=%d", rc));
+        failed = true;
+    }
+    else
+    {
+        uint8_t id;
+        rc = sd_bus_message_read_basic(msg, 'y', &id);
+        if (rc < 0)
+        {
+            log<level::ERR>("Could not read instance ID out of message",
+                            entry("ERROR=%d", rc));
+            failed = true;
+        }
+        else
+        {
+            _instanceID = id;
+        }
+    }
+
+    if (failed)
+    {
+        _inProgress = false;
+        callResponseFunc(ResponseStatus::failure);
+    }
+    else
+    {
+        startCommand();
+    }
+}
+
+int iidCallback(sd_bus_message* msg, void* data, sd_bus_error* err)
+{
+    auto* interface = static_cast<PLDMInterface*>(data);
+    interface->instanceIDCallback(msg);
+    return 0;
+}
+
+void PLDMInterface::startCommand()
 {
     try
     {
@@ -92,23 +162,59 @@
 
         open();
 
-        readInstanceID();
-
         registerReceiveCallback();
 
-        doSend(id, size);
+        doSend();
+
+        _receiveTimer.restartOnce(_receiveTimeout);
     }
     catch (const std::exception& e)
     {
-        closeFD();
+        cleanupCmd();
 
+        callResponseFunc(ResponseStatus::failure);
+    }
+}
+
+void PLDMInterface::startReadInstanceID()
+{
+    auto rc = sd_bus_call_method_async(
+        _bus, NULL, service::pldm, object_path::pldm, interface::pldm_requester,
+        "GetInstanceId", iidCallback, this, "y", _eid);
+
+    if (rc < 0)
+    {
+        log<level::ERR>("Error calling sd_bus_call_method_async",
+                        entry("RC=%d", rc), entry("MSG=%s", strerror(-rc)));
+        throw std::exception{};
+    }
+}
+
+CmdStatus PLDMInterface::sendNewLogCmd(uint32_t id, uint32_t size)
+{
+    _pelID = id;
+    _pelSize = size;
+    _inProgress = true;
+
+    try
+    {
+        // Kick off the async call to get the instance ID if
+        // necessary, otherwise start the command itself.
+        if (!_instanceID)
+        {
+            startReadInstanceID();
+        }
+        else
+        {
+            startCommand();
+        }
+    }
+    catch (const std::exception& e)
+    {
         _inProgress = false;
-        _source.reset();
         return CmdStatus::failure;
     }
 
-    _inProgress = true;
-    _receiveTimer.restartOnce(_receiveTimeout);
     return CmdStatus::success;
 }
 
@@ -121,30 +227,16 @@
                   std::placeholders::_3));
 }
 
-void PLDMInterface::readInstanceID()
-{
-    try
-    {
-        _instanceID = _dataIface.getPLDMInstanceID(_eid);
-    }
-    catch (const std::exception& e)
-    {
-        log<level::ERR>(
-            "Failed to get instance ID from PLDM Requester D-Bus daemon",
-            entry("ERROR=%s", e.what()));
-        throw;
-    }
-}
-
-void PLDMInterface::doSend(uint32_t id, uint32_t size)
+void PLDMInterface::doSend()
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(pelFileType) +
-                            sizeof(id) + sizeof(uint64_t)>
+                            sizeof(_pelID) + sizeof(uint64_t)>
         requestMsg;
 
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-    auto rc = encode_new_file_req(_instanceID, pelFileType, id, size, request);
+    auto rc = encode_new_file_req(*_instanceID, pelFileType, _pelID, _pelSize,
+                                  request);
     if (rc != PLDM_SUCCESS)
     {
         log<level::ERR>("encode_new_file_req failed", entry("RC=%d", rc));
@@ -173,7 +265,7 @@
     size_t responseSize = 0;
     ResponseStatus status = ResponseStatus::success;
 
-    auto rc = pldm_recv(_eid, fd, _instanceID, &responseMsg, &responseSize);
+    auto rc = pldm_recv(_eid, fd, *_instanceID, &responseMsg, &responseSize);
     if (rc < 0)
     {
         if (rc == PLDM_REQUESTER_INSTANCE_ID_MISMATCH)
@@ -196,10 +288,10 @@
         responseMsg = nullptr;
     }
 
-    _inProgress = false;
-    _receiveTimer.setEnabled(false);
-    closeFD();
-    _source.reset();
+    cleanupCmd();
+
+    // Can't use this instance ID anymore.
+    _instanceID = std::nullopt;
 
     if (status == ResponseStatus::success)
     {
@@ -236,13 +328,22 @@
 void PLDMInterface::receiveTimerExpired()
 {
     log<level::ERR>("Timed out waiting for PLDM response");
-    cancelCmd();
+
+    // Cleanup, but keep the instance ID because the host didn't
+    // respond so we can still use it.
+    cleanupCmd();
 
     callResponseFunc(ResponseStatus::failure);
 }
 
 void PLDMInterface::cancelCmd()
 {
+    _instanceID = std::nullopt;
+    cleanupCmd();
+}
+
+void PLDMInterface::cleanupCmd()
+{
     _inProgress = false;
     _source.reset();