diff --git a/dump_manager_faultlog.cpp b/dump_manager_faultlog.cpp
new file mode 100644
index 0000000..a718472
--- /dev/null
+++ b/dump_manager_faultlog.cpp
@@ -0,0 +1,116 @@
+#include "config.h"
+
+#include "dump_manager_faultlog.hpp"
+
+#include "faultlog_dump_entry.hpp"
+
+#include <fmt/core.h>
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <xyz/openbmc_project/Common/File/error.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace phosphor
+{
+namespace dump
+{
+namespace faultlog
+{
+
+using namespace phosphor::logging;
+using namespace sdbusplus::xyz::openbmc_project::Common::Error;
+using namespace sdbusplus::xyz::openbmc_project::Common::File::Error;
+using ErrnoOpen = xyz::openbmc_project::Common::File::Open::ERRNO;
+using PathOpen = xyz::openbmc_project::Common::File::Open::PATH;
+
+sdbusplus::message::object_path
+    Manager::createDump(phosphor::dump::DumpCreateParams params)
+{
+    log<level::INFO>("In dump_manager_fault.cpp createDump");
+
+    // Currently we ignore the parameters.
+    // TODO phosphor-debug-collector/issues/22: Check parameter values and
+    // exit early if we don't receive the expected parameters
+    if (params.empty())
+    {
+        log<level::INFO>("No additional parameters received");
+    }
+    else
+    {
+        log<level::INFO>("Got additional parameters");
+    }
+
+    // Get the id
+    auto id = lastEntryId + 1;
+    auto idString = std::to_string(id);
+    auto objPath = std::filesystem::path(baseEntryPath) / idString;
+
+    std::filesystem::path faultLogFilePath(std::string(FAULTLOG_DUMP_PATH) +
+                                           idString);
+    std::ofstream faultLogFile;
+
+    errno = 0;
+
+    faultLogFile.open(faultLogFilePath,
+                      std::ofstream::out | std::fstream::trunc);
+
+    if (faultLogFile.is_open())
+    {
+        log<level::INFO>("faultLogFile is open");
+
+        faultLogFile << "This is faultlog file #" << idString << " at "
+                     << std::string(FAULTLOG_DUMP_PATH) + idString << std::endl;
+
+        faultLogFile.close();
+    }
+    else
+    {
+        log<level::ERR>(fmt::format("Failed to open fault log file at {}, "
+                                    "errno({}), strerror(\"{}\"), "
+                                    "OBJECTPATH({}), ID({})",
+                                    faultLogFilePath.c_str(), errno,
+                                    strerror(errno), objPath.c_str(), id)
+                            .c_str());
+        elog<Open>(ErrnoOpen(errno), PathOpen(objPath.c_str()));
+    }
+
+    try
+    {
+        log<level::INFO>("dump_manager_faultlog.cpp: add faultlog entry");
+
+        uint64_t timestamp =
+            std::chrono::duration_cast<std::chrono::microseconds>(
+                std::chrono::system_clock::now().time_since_epoch())
+                .count();
+
+        entries.insert(std::make_pair(
+            id,
+            std::make_unique<faultlog::Entry>(
+                bus, objPath.c_str(), id, timestamp,
+                std::filesystem::file_size(faultLogFilePath), faultLogFilePath,
+                phosphor::dump::OperationStatus::Completed, *this)));
+    }
+    catch (const std::invalid_argument& e)
+    {
+        log<level::ERR>(fmt::format("Error in creating dump entry, "
+                                    "errormsg({}), OBJECTPATH({}), ID({})",
+                                    e.what(), objPath.c_str(), id)
+                            .c_str());
+        elog<InternalFailure>();
+    }
+
+    lastEntryId++;
+
+    log<level::INFO>("End of dump_manager_faultlog.cpp createDump");
+    return objPath.string();
+}
+
+} // namespace faultlog
+} // namespace dump
+} // namespace phosphor
diff --git a/dump_manager_faultlog.hpp b/dump_manager_faultlog.hpp
new file mode 100644
index 0000000..56b1bd6
--- /dev/null
+++ b/dump_manager_faultlog.hpp
@@ -0,0 +1,87 @@
+#pragma once
+
+#include "dump_manager.hpp"
+
+#include <fmt/core.h>
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server/object.hpp>
+#include <xyz/openbmc_project/Dump/Create/server.hpp>
+
+namespace phosphor
+{
+namespace dump
+{
+namespace faultlog
+{
+
+using namespace phosphor::logging;
+
+using CreateIface = sdbusplus::server::object::object<
+    sdbusplus::xyz::openbmc_project::Dump::server::Create>;
+
+/** @class Manager
+ *  @brief FaultLog Dump manager implementation.
+ */
+class Manager :
+    virtual public CreateIface,
+    virtual public phosphor::dump::Manager
+{
+  public:
+    Manager() = delete;
+    Manager(const Manager&) = default;
+    Manager& operator=(const Manager&) = delete;
+    Manager(Manager&&) = delete;
+    Manager& operator=(Manager&&) = delete;
+    virtual ~Manager() = default;
+
+    /** @brief Constructor to put object onto bus at a dbus path.
+     *  @param[in] bus - Bus to attach to.
+     *  @param[in] path - Path to attach at.
+     *  @param[in] baseEntryPath - Base path for dump entry.
+     *  @param[in] filePath - Path where the dumps are stored.
+     */
+    Manager(sdbusplus::bus::bus& bus, const char* path,
+            const std::string& baseEntryPath, const char* filePath) :
+        CreateIface(bus, path),
+        phosphor::dump::Manager(bus, path, baseEntryPath), dumpDir(filePath)
+    {
+        std::error_code ec;
+
+        std::filesystem::create_directory(FAULTLOG_DUMP_PATH, ec);
+
+        if (ec)
+        {
+            log<level::ERR>(fmt::format("dump_manager_faultlog directory {} "
+                                        "not created. error_code = {} ({})",
+                                        FAULTLOG_DUMP_PATH, ec.value(),
+                                        ec.message())
+                                .c_str());
+        }
+    }
+
+    void restore() override
+    {
+        // TODO phosphor-debug-collector/issues/21: Restore fault log entries
+        // after service restart
+        log<level::INFO>("dump_manager_faultlog restore not implemented");
+    }
+
+    /** @brief Method to create a new fault log dump entry
+     *  @param[in] params - Key-value pair input parameters
+     *
+     *  @return object_path - The path to the new dump entry.
+     */
+    sdbusplus::message::object_path
+        createDump(phosphor::dump::DumpCreateParams params) override;
+
+  private:
+    /** @brief Path to the dump file*/
+    std::string dumpDir;
+};
+
+} // namespace faultlog
+} // namespace dump
+} // namespace phosphor
diff --git a/dump_manager_main.cpp b/dump_manager_main.cpp
index ce858e4..55f4812 100644
--- a/dump_manager_main.cpp
+++ b/dump_manager_main.cpp
@@ -4,6 +4,7 @@
 #include "dump_internal.hpp"
 #include "dump_manager.hpp"
 #include "dump_manager_bmc.hpp"
+#include "dump_manager_faultlog.hpp"
 #include "elog_watch.hpp"
 #include "watch.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
@@ -78,6 +79,12 @@
                                                    OBJ_INTERNAL);
         dumpMgrList.push_back(std::move(bmcDumpMgr));
 
+        std::unique_ptr<phosphor::dump::faultlog::Manager> faultLogMgr =
+            std::make_unique<phosphor::dump::faultlog::Manager>(
+                bus, FAULTLOG_DUMP_OBJPATH, FAULTLOG_DUMP_OBJ_ENTRY,
+                FAULTLOG_DUMP_PATH);
+        dumpMgrList.push_back(std::move(faultLogMgr));
+
         phosphor::dump::loadExtensions(bus, dumpMgrList);
 
         // Restore dbus objects of all dumps
diff --git a/faultlog_dump_entry.cpp b/faultlog_dump_entry.cpp
new file mode 100644
index 0000000..897d98b
--- /dev/null
+++ b/faultlog_dump_entry.cpp
@@ -0,0 +1,38 @@
+#include "faultlog_dump_entry.hpp"
+
+#include <fmt/core.h>
+
+#include <phosphor-logging/log.hpp>
+
+namespace phosphor
+{
+namespace dump
+{
+namespace faultlog
+{
+using namespace phosphor::logging;
+
+void Entry::delete_()
+{
+    log<level::INFO>("In faultlog_dump_entry.cpp delete_()");
+
+    // Delete Dump file from Permanent location
+    try
+    {
+        std::filesystem::remove(file);
+    }
+    catch (const std::filesystem::filesystem_error& e)
+    {
+        // Log Error message and continue
+        log<level::ERR>(
+            fmt::format("Failed to delete dump file, errormsg({})", e.what())
+                .c_str());
+    }
+
+    // Remove Dump entry D-bus object
+    phosphor::dump::Entry::delete_();
+}
+
+} // namespace faultlog
+} // namespace dump
+} // namespace phosphor
diff --git a/faultlog_dump_entry.hpp b/faultlog_dump_entry.hpp
new file mode 100644
index 0000000..50f97cd
--- /dev/null
+++ b/faultlog_dump_entry.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "dump_entry.hpp"
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server/object.hpp>
+#include <xyz/openbmc_project/Object/Delete/server.hpp>
+#include <xyz/openbmc_project/Time/EpochTime/server.hpp>
+
+#include <filesystem>
+
+namespace phosphor
+{
+namespace dump
+{
+namespace faultlog
+{
+template <typename T>
+using ServerObject = typename sdbusplus::server::object::object<T>;
+
+using EntryIfaces = sdbusplus::server::object::object<>;
+
+class Manager;
+
+/** @class Entry
+ *  @brief OpenBMC Fault Log Dump Entry implementation.
+ */
+class Entry : virtual public EntryIfaces, virtual public phosphor::dump::Entry
+{
+  public:
+    Entry() = delete;
+    Entry(const Entry&) = delete;
+    Entry& operator=(const Entry&) = delete;
+    Entry(Entry&&) = delete;
+    Entry& operator=(Entry&&) = delete;
+    ~Entry() = default;
+
+    /** @brief Constructor for the Dump Entry Object
+     *  @param[in] bus - Bus to attach to.
+     *  @param[in] objPath - Object path to attach to
+     *  @param[in] dumpId - Dump id.
+     *  @param[in] timeStamp - Dump creation timestamp
+     *             in microseconds since the epoch.
+     *  @param[in] fileSize - Dump file size in bytes.
+     *  @param[in] file - Full path of dump file.
+     *  @param[in] status - status of the dump.
+     *  @param[in] parent - The dump entry's parent.
+     */
+    Entry(sdbusplus::bus::bus& bus, const std::string& objPath, uint32_t dumpId,
+          uint64_t timeStamp, uint64_t fileSize,
+          const std::filesystem::path& file,
+          phosphor::dump::OperationStatus status,
+          phosphor::dump::Manager& parent) :
+        EntryIfaces(bus, objPath.c_str(), EntryIfaces::action::defer_emit),
+        phosphor::dump::Entry(bus, objPath.c_str(), dumpId, timeStamp, fileSize,
+                              status, parent),
+        file(file)
+    {
+        // Emit deferred signal.
+        this->phosphor::dump::faultlog::EntryIfaces::emit_object_added();
+    }
+
+    /** @brief Delete this d-bus object.
+     */
+    void delete_() override;
+
+  private:
+    /** @Dump file path */
+    std::filesystem::path file;
+};
+
+} // namespace faultlog
+} // namespace dump
+} // namespace phosphor
diff --git a/meson.build b/meson.build
index 0825c96..2b3e7f5 100644
--- a/meson.build
+++ b/meson.build
@@ -113,6 +113,15 @@
 conf_data.set('JFFS_CORE_FILE_WORKAROUND', get_option('jffs-workaround').enabled(),
                description : 'Turn on jffs workaround for core file'
              )
+conf_data.set_quoted('FAULTLOG_DUMP_OBJ_ENTRY', get_option('FAULTLOG_DUMP_OBJ_ENTRY'),
+                      description : 'The Fault Log dump entry DBus object path'
+                    )
+conf_data.set_quoted('FAULTLOG_DUMP_OBJPATH', get_option('FAULTLOG_DUMP_OBJPATH'),
+                      description : 'The Fault Log Dump manager Dbus path'
+                    )
+conf_data.set_quoted('FAULTLOG_DUMP_PATH', get_option('FAULTLOG_DUMP_PATH'),
+                      description : 'Directory where fault logs are placed'
+                    )
 
 configure_file(configuration : conf_data,
                output : 'config.h'
@@ -152,7 +161,9 @@
         'watch.cpp',
         'bmc_dump_entry.cpp',
         'dump_utils.cpp',
-        'dump_offload.cpp'
+        'dump_offload.cpp',
+        'dump_manager_faultlog.cpp',
+        'faultlog_dump_entry.cpp',
     ]
 
 phosphor_dump_manager_dependency = [
diff --git a/meson_options.txt b/meson_options.txt
index a4788f9..cef17e4 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -85,6 +85,23 @@
         description : 'Enable Open Power specific dumps'
       )
 
+# Fault log options
+
+option('FAULTLOG_DUMP_PATH', type : 'string',
+        value : '/var/lib/phosphor-debug-collector/faultlogs/',
+        description : 'Directory where fault logs are placed'
+      )
+
+option('FAULTLOG_DUMP_OBJPATH', type : 'string',
+        value : '/xyz/openbmc_project/dump/faultlog',
+        description : 'The fault log dump manager D-Bus object path'
+      )
+
+option('FAULTLOG_DUMP_OBJ_ENTRY', type : 'string',
+        value : '/xyz/openbmc_project/dump/faultlog/entry',
+        description : 'The fault log dump entry D-Bus object path'
+      )
+
 # Configurations for openpower-dump extension
 
 # System dump options