diff --git a/phalerror/create_pel.cpp b/phalerror/create_pel.cpp
new file mode 100644
index 0000000..3a047d3
--- /dev/null
+++ b/phalerror/create_pel.cpp
@@ -0,0 +1,89 @@
+#include "create_pel.hpp"
+
+#include <libekb.H>
+#include <unistd.h>
+
+#include <map>
+#include <phosphor-logging/elog.hpp>
+#include <xyz/openbmc_project/Logging/Entry/server.hpp>
+namespace openpower
+{
+using namespace phosphor::logging;
+
+namespace util
+{
+std::string getService(sdbusplus::bus::bus& bus, const std::string& objectPath,
+                       const std::string& interface)
+{
+    constexpr auto mapperBusBame = "xyz.openbmc_project.ObjectMapper";
+    constexpr auto mapperObjectPath = "/xyz/openbmc_project/object_mapper";
+    constexpr auto mapperInterface = "xyz.openbmc_project.ObjectMapper";
+    std::vector<std::pair<std::string, std::vector<std::string>>> response;
+    auto method = bus.new_method_call(mapperBusBame, mapperObjectPath,
+                                      mapperInterface, "GetObject");
+    method.append(objectPath, std::vector<std::string>({interface}));
+    try
+    {
+        auto reply = bus.call(method);
+        reply.read(response);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        log<level::ERR>("D-Bus call exception",
+                        entry("OBJPATH=%s", mapperObjectPath),
+                        entry("INTERFACE=%s", mapperInterface),
+                        entry("EXCEPTION=%s", e.what()));
+
+        throw std::runtime_error("Service name is not found");
+    }
+
+    if (response.empty())
+    {
+        throw std::runtime_error("Service name response is empty");
+    }
+    return response.begin()->first;
+}
+} // namespace util
+
+namespace pel
+{
+void createBootErrorPEL(const FFDCData& ffdcData)
+{
+    constexpr auto loggingObjectPath = "/xyz/openbmc_project/logging";
+    constexpr auto loggingInterface = "xyz.openbmc_project.Logging.Create";
+
+    std::map<std::string, std::string> additionalData;
+    auto bus = sdbusplus::bus::new_default();
+    additionalData.emplace("_PID", std::to_string(getpid()));
+    for (auto& data : ffdcData)
+    {
+        additionalData.emplace(data);
+    }
+    try
+    {
+        static constexpr auto bootErrorMessage =
+            "org.open_power.PHAL.Error.Boot";
+        std::string service =
+            util::getService(bus, loggingObjectPath, loggingInterface);
+        auto method = bus.new_method_call(service.c_str(), loggingObjectPath,
+                                          loggingInterface, "Create");
+        auto level =
+            sdbusplus::xyz::openbmc_project::Logging::server::convertForMessage(
+                sdbusplus::xyz::openbmc_project::Logging::server::Entry::Level::
+                    Error);
+        method.append(bootErrorMessage, level, additionalData);
+        auto resp = bus.call(method);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        log<level::ERR>("D-Bus call exception",
+                        entry("OBJPATH=%s", loggingObjectPath),
+                        entry("INTERFACE=%s", loggingInterface),
+                        entry("EXCEPTION=%s", e.what()));
+
+        throw std::runtime_error(
+            "Error in invoking D-Bus logging create interface");
+    }
+}
+} // namespace pel
+} // namespace openpower
diff --git a/phalerror/create_pel.hpp b/phalerror/create_pel.hpp
new file mode 100644
index 0000000..b80b642
--- /dev/null
+++ b/phalerror/create_pel.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <sdbusplus/bus.hpp>
+#include <string>
+#include <vector>
+namespace openpower
+{
+namespace util
+{
+/**
+ * Get D-Bus service name for the specified object and interface
+ *
+ * @param[in] bus - sdbusplus D-Bus to attach to
+ * @param[in] objectPath - D-Bus object path
+ * @param[in] interface - D-Bus interface name
+ *
+ * @return service name on success and exception on failure
+ */
+std::string getService(sdbusplus::bus::bus& bus, const std::string& objectPath,
+                       const std::string& interface);
+} // namespace util
+namespace pel
+{
+using FFDCData = std::vector<std::pair<std::string, std::string>>;
+/**
+ * Create boot error PEL
+ *
+ * @param[in] ffdcData - failure data to append to PEL
+ */
+void createBootErrorPEL(const FFDCData& ffdcData);
+
+} // namespace pel
+} // namespace openpower
diff --git a/phalerror/phal_error.cpp b/phalerror/phal_error.cpp
new file mode 100644
index 0000000..4f33ff2
--- /dev/null
+++ b/phalerror/phal_error.cpp
@@ -0,0 +1,101 @@
+#include "phal_error.hpp"
+
+#include "create_pel.hpp"
+
+#include <libekb.H>
+#include <libipl.H>
+
+#include <iomanip>
+#include <phosphor-logging/elog.hpp>
+#include <sstream>
+
+namespace openpower
+{
+namespace pel
+{
+using namespace phosphor::logging;
+
+namespace detail
+{
+
+// keys need to be unique so using counter value to generate unique key
+static int counter = 0;
+
+// list of debug traces
+static std::vector<std::pair<std::string, std::string>> traceLog;
+
+void processLogTraceCallback(void* private_data, const char* fmt, va_list ap)
+{
+    va_list vap;
+    va_copy(vap, ap);
+    std::vector<char> log(1 + std::vsnprintf(nullptr, 0, fmt, ap));
+    std::vsnprintf(log.data(), log.size(), fmt, vap);
+    va_end(vap);
+    std::string logstr(log.begin(), log.end());
+
+    // ignore stray characters in log traces coming from ekb
+    // example: "\n", which are good for print to screen
+    if (logstr.length() < 5)
+    {
+        return;
+    }
+
+    char timeBuf[80];
+    time_t t = time(0);
+    tm myTm{};
+    gmtime_r(&t, &myTm);
+    strftime(timeBuf, 80, "%Y-%m-%d %H:%M:%S", &myTm);
+
+    // key values need to be unique for PEL
+    // TODO #openbmc/dev/issues/1563
+    // If written to Json no need to worry about unique KEY
+    std::stringstream str;
+    str << std::setfill('0');
+    str << "LOG" << std::setw(3) << counter;
+    str << " " << timeBuf;
+    traceLog.emplace_back(std::make_pair(str.str(), std::move(logstr)));
+    counter++;
+}
+
+void processBootErrorCallback(bool status)
+{
+    log<level::INFO>("processBootCallback ", entry("STATUS=%d", status));
+    try
+    {
+        // If failure in hwp execution
+        if (!status)
+        {
+            FFDCData ffdc = libekb_get_ffdc();
+            ffdc.insert(ffdc.end(), traceLog.begin(), traceLog.end());
+            openpower::pel::createBootErrorPEL(ffdc);
+        }
+    }
+    catch (std::exception& ex)
+    {
+        reset();
+        throw ex;
+    }
+    reset();
+}
+
+void reset()
+{
+    // reset the trace log and counter
+    traceLog.clear();
+    counter = 0;
+}
+} // namespace detail
+
+void addBootErrorCallbacks()
+{
+    // set log level to info
+    ipl_set_loglevel(IPL_INFO);
+
+    // add callback for debug traces
+    ipl_set_logfunc(detail::processLogTraceCallback, NULL);
+
+    // add callback for ipl failures
+    ipl_set_app_callback_func(detail::processBootErrorCallback);
+}
+} // namespace pel
+} // namespace openpower
diff --git a/phalerror/phal_error.hpp b/phalerror/phal_error.hpp
new file mode 100644
index 0000000..055cf35
--- /dev/null
+++ b/phalerror/phal_error.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstdarg>
+namespace openpower
+{
+namespace pel
+{
+namespace detail
+{
+
+/**
+ * @brief Process debug traces
+ *
+ * Function adds debug traces to the list so that it will be added to the
+ * PEL upon failure
+ *
+ * @param[in] private_data - pointer to private data, unused now
+ * @param[in] fmt - format for variable list arguments
+ * @param[in] ap - object of va_list, holds information needed to retrieve
+ *                 the additional arguments
+ */
+
+void processLogTraceCallback(void* private_data, const char* fmt, va_list ap);
+
+/**
+ * @brief Process boot failure/success status
+ *
+ * If status is success log traces are cleared else used in the
+ * creation of failure
+ *
+ * @param[in] status - Boot execution status
+ */
+void processBootErrorCallback(bool status);
+
+/**
+ * @brief Reset trace log list
+ */
+void reset();
+} // namespace detail
+
+/**
+ * @brief Add callbacks for debug traces and boot errors
+ *
+ * This function adds callback for debug traces and for boot
+ * errors
+ */
+void addBootErrorCallbacks();
+} // namespace pel
+} // namespace openpower