diff --git a/include/rde/external_storer_file.hpp b/include/rde/external_storer_file.hpp
new file mode 100644
index 0000000..3d12dc9
--- /dev/null
+++ b/include/rde/external_storer_file.hpp
@@ -0,0 +1,139 @@
+#pragma once
+
+#include "external_storer_interface.hpp"
+#include "nlohmann/json.hpp"
+
+#include <boost/uuid/uuid_generators.hpp>
+
+#include <filesystem>
+#include <string>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+/**
+ * @brief Simple Base class for writing JSON data to files.
+ *
+ * This class allows us to unit test the ExternalStorerFileInterface
+ * functionality.
+ */
+class FileHandlerInterface
+{
+  public:
+    virtual ~FileHandlerInterface() = default;
+
+    /**
+     * @brief Create a folder at the provided path.
+     *
+     * @param[in] folderPath - folder path.
+     * @return true if successful.
+     */
+    virtual bool createFolder(const std::string& folderPath) const = 0;
+
+    /**
+     * @brief Create an index.json and write the JSON content to it.
+     *
+     * If the file already exists, this will overwrite it.
+     *
+     * @param[in] folderPath - path of the file without including the file name.
+     * @param[in] jsonPdr - PDR in nlohmann::json format.
+     * @return true if successful.
+     */
+    virtual bool createFile(const std::string& folderPath,
+                            const nlohmann::json& jsonPdr) const = 0;
+};
+
+/**
+ * @brief Class for handling folder and file creation for ExternalStorer.
+ */
+class ExternalStorerFileWriter : public FileHandlerInterface
+{
+  public:
+    bool createFolder(const std::string& folderPath) const override;
+    bool createFile(const std::string& folderPath,
+                    const nlohmann::json& jsonPdr) const override;
+};
+
+/**
+ * @brief Categories for different redfish JSON strings.
+ */
+enum class JsonPdrType
+{
+    logEntry,
+    logService,
+    other
+};
+
+/**
+ * @brief Class for handling ExternalStorer file operations.
+ */
+class ExternalStorerFileInterface : public ExternalStorerInterface
+{
+  public:
+    /**
+     * @brief Constructor for the ExternalStorerFileInterface.
+     *
+     * @param[in] rootPath - root path for creating redfish folders.
+     * Eg: "/run/bmcweb"
+     * @param[in] fileHandler - an ExternalStorerFileWriter object. This class
+     * will take the ownership of this object.
+     */
+    ExternalStorerFileInterface(
+        std::string_view rootPath,
+        std::unique_ptr<FileHandlerInterface> fileHandler);
+
+    bool publishJson(std::string_view jsonStr) override;
+
+  private:
+    std::string rootPath;
+    std::unique_ptr<FileHandlerInterface> fileHandler;
+    std::string logServiceId;
+    boost::uuids::random_generator randomGen;
+
+    /**
+     * @brief Get the type of the received PDR.
+     *
+     * @param[in] jsonSchema - PDR in nlohmann::json format.
+     * @return JsonPdrType of the PDR.
+     */
+    JsonPdrType getSchemaType(const nlohmann::json& jsonSchema) const;
+
+    /**
+     * @brief Process a LogEntry type PDR.
+     *
+     * @param[in] logEntry - PDR in nlohmann::json format.
+     * @return true if successful.
+     */
+    bool processLogEntry(nlohmann::json& logEntry);
+
+    /**
+     * @brief Process a LogService type PDR.
+     *
+     * @param[in] logService - PDR in nlohmann::json format.
+     * @return true if successful.
+     */
+    bool processLogService(const nlohmann::json& logService);
+
+    /**
+     * @brief Process PDRs that doesn't have a specific category.
+     *
+     * @param[in] jsonPdr - PDR in nlohmann::json format.
+     * @return true if successful.
+     */
+    bool processOtherTypes(const nlohmann::json& jsonPdr) const;
+
+    /**
+     * @brief Create the needed folders and the index.json.
+     *
+     * @param subPath - path within the root folder.
+     * @param jsonPdr - PDR in nlohmann::json format.
+     * @return true if successful.
+     */
+    bool createFile(const std::string& subPath,
+                    const nlohmann::json& jsonPdr) const;
+};
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/include/rde/external_storer_interface.hpp b/include/rde/external_storer_interface.hpp
new file mode 100644
index 0000000..05a8616
--- /dev/null
+++ b/include/rde/external_storer_interface.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string_view>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+/**
+ * @brief Base class for publishing data to ExternalStorer.
+ */
+class ExternalStorerInterface
+{
+  public:
+    virtual ~ExternalStorerInterface() = default;
+
+    /**
+     * @brief Publish JSON string to ExternalStorer.
+     *
+     * @param[in] jsonStr - a valid JSON string.
+     * @return true if successful.
+     */
+    virtual bool publishJson(std::string_view jsonStr) = 0;
+};
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/src/rde/external_storer_file.cpp b/src/rde/external_storer_file.cpp
new file mode 100644
index 0000000..0768134
--- /dev/null
+++ b/src/rde/external_storer_file.cpp
@@ -0,0 +1,180 @@
+#include "rde/external_storer_file.hpp"
+
+#include <fmt/format.h>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <fstream>
+#include <string_view>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+bool ExternalStorerFileWriter::createFolder(const std::string& folderPath) const
+{
+    std::filesystem::path path(folderPath);
+    if (!std::filesystem::is_directory(path))
+    {
+        if (!std::filesystem::create_directories(path))
+        {
+            fmt::print(stderr, "Failed to create a folder at {}\n", folderPath);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool ExternalStorerFileWriter::createFile(const std::string& folderPath,
+                                          const nlohmann::json& jsonPdr) const
+{
+    if (!createFolder(folderPath))
+    {
+        return false;
+    }
+    std::filesystem::path path(folderPath);
+    path /= "index.json";
+    // If the file already exist, overwrite it.
+    std::ofstream output(path);
+    output << jsonPdr;
+    output.close();
+    return true;
+}
+
+ExternalStorerFileInterface::ExternalStorerFileInterface(
+    std::string_view rootPath,
+    std::unique_ptr<FileHandlerInterface> fileHandler) :
+    rootPath(rootPath),
+    fileHandler(std::move(fileHandler)), logServiceId("")
+{}
+
+bool ExternalStorerFileInterface::publishJson(std::string_view jsonStr)
+{
+    nlohmann::json jsonDecoded;
+    try
+    {
+        jsonDecoded = nlohmann::json::parse(jsonStr);
+    }
+    catch (nlohmann::json::parse_error& e)
+    {
+        fmt::print(stderr, "JSON parse error: \n{}\n", e.what());
+        return false;
+    }
+
+    // We need to know the type to determine how to process the decoded JSON
+    // output.
+    if (!jsonDecoded.contains("@odata.type"))
+    {
+        fmt::print(stderr, "@odata.type field doesn't exist in:\n {}\n",
+                   jsonDecoded.dump(4));
+        return false;
+    }
+
+    auto schemaType = getSchemaType(jsonDecoded);
+    if (schemaType == JsonPdrType::logEntry)
+    {
+        return processLogEntry(jsonDecoded);
+    }
+    if (schemaType == JsonPdrType::logService)
+    {
+        return processLogService(jsonDecoded);
+    }
+    return processOtherTypes(jsonDecoded);
+}
+
+JsonPdrType ExternalStorerFileInterface::getSchemaType(
+    const nlohmann::json& jsonSchema) const
+{
+    auto logEntryFound =
+        std::string(jsonSchema["@odata.type"]).find("LogEntry");
+    if (logEntryFound != std::string::npos)
+    {
+        return JsonPdrType::logEntry;
+    }
+
+    auto logServiceFound =
+        std::string(jsonSchema["@odata.type"]).find("LogService");
+    if (logServiceFound != std::string::npos)
+    {
+        return JsonPdrType::logService;
+    }
+
+    return JsonPdrType::other;
+}
+
+bool ExternalStorerFileInterface::processLogEntry(nlohmann::json& logEntry)
+{
+    // TODO: Add policies for LogEntry retention.
+    // https://github.com/openbmc/bios-bmc-smm-error-logger/issues/1.
+    if (logServiceId.empty())
+    {
+        fmt::print(stderr, "First need a LogService PDR with a new UUID.\n");
+        return false;
+    }
+
+    std::string id = boost::uuids::to_string(randomGen());
+    std::string path = "/redfish/v1/Systems/system/LogServices/" +
+                       logServiceId + "/Entries/" + id;
+
+    // Populate the "Id" with the UUID we generated.
+    logEntry["Id"] = id;
+    // Remove the @odata.id from the JSON since ExternalStorer will fill it for
+    // a client.
+    logEntry.erase("@odata.id");
+
+    return createFile(path, logEntry);
+}
+
+bool ExternalStorerFileInterface::processLogService(
+    const nlohmann::json& logService)
+{
+    if (!logService.contains("@odata.id"))
+    {
+        fmt::print(stderr, "@odata.id field doesn't exist in:\n {}\n",
+                   logService.dump(4));
+        return false;
+    }
+
+    if (!logService.contains("Id"))
+    {
+        fmt::print(stderr, "Id field doesn't exist in:\n {}\n",
+                   logService.dump(4));
+        return false;
+    }
+
+    logServiceId = logService["Id"].get<std::string>();
+
+    if (!createFile(logService["@odata.id"].get<std::string>(), logService))
+    {
+        fmt::print(stderr, "Failed to create LogService index file for:\n{}\n",
+                   logService.dump(4));
+        return false;
+    }
+    // ExternalStorer needs a .../Entries/index.json file with no data.
+    nlohmann::json jEmpty = "{}"_json;
+    return createFile(logService["@odata.id"].get<std::string>() + "/Entries",
+                      jEmpty);
+}
+
+bool ExternalStorerFileInterface::processOtherTypes(
+    const nlohmann::json& jsonPdr) const
+{
+    if (!jsonPdr.contains("@odata.id"))
+    {
+        fmt::print(stderr, "@odata.id field doesn't exist in:\n {}\n",
+                   jsonPdr.dump(4));
+        return false;
+    }
+    return createFile(jsonPdr["@odata.id"].get<std::string>(), jsonPdr);
+}
+
+bool ExternalStorerFileInterface::createFile(
+    const std::string& subPath, const nlohmann::json& jsonPdr) const
+{
+    return fileHandler->createFile(rootPath + subPath, jsonPdr);
+}
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/src/rde/meson.build b/src/rde/meson.build
index 4e6220f..482e9ff 100644
--- a/src/rde/meson.build
+++ b/src/rde/meson.build
@@ -1,6 +1,7 @@
 rde_lib = static_library(
   'rde',
   'rde_dictionary_manager.cpp',
+  'external_storer_file.cpp',
   include_directories : rde_inc,
   implicit_include_directories: false)
 
diff --git a/test/external_storer_file_test.cpp b/test/external_storer_file_test.cpp
new file mode 100644
index 0000000..fc550ee
--- /dev/null
+++ b/test/external_storer_file_test.cpp
@@ -0,0 +1,189 @@
+#include "rde/external_storer_file.hpp"
+
+#include <string_view>
+
+#include <gmock/gmock-matchers.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace bios_bmc_smm_error_logger
+{
+namespace rde
+{
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Return;
+using ::testing::SaveArg;
+
+class MockFileWriter : public FileHandlerInterface
+{
+  public:
+    MOCK_METHOD(bool, createFolder, (const std::string& path),
+                (const, override));
+    MOCK_METHOD(bool, createFile,
+                (const std::string& path, const nlohmann::json& jsonPdr),
+                (const, override));
+};
+
+class ExternalStorerFileTest : public ::testing::Test
+{
+  public:
+    ExternalStorerFileTest() :
+        mockFileWriter(std::make_unique<MockFileWriter>())
+    {
+        mockFileWriterPtr = dynamic_cast<MockFileWriter*>(mockFileWriter.get());
+        exStorer = std::make_unique<ExternalStorerFileInterface>(
+            rootPath, std::move(mockFileWriter));
+    }
+
+  protected:
+    std::unique_ptr<FileHandlerInterface> mockFileWriter;
+    std::unique_ptr<ExternalStorerFileInterface> exStorer;
+    MockFileWriter* mockFileWriterPtr;
+    const std::string rootPath = "/some/path";
+};
+
+TEST_F(ExternalStorerFileTest, InvalidJsonTest)
+{
+    // Try an invalid JSON.
+    std::string jsonStr = "Invalid JSON";
+    EXPECT_THAT(exStorer->publishJson(jsonStr), false);
+}
+
+TEST_F(ExternalStorerFileTest, NoOdataTypeFailureTest)
+{
+    // Try a JSON without @odata.type.
+    std::string jsonStr = R"(
+      {
+        "@odata.id": "/redfish/v1/Systems/system/Memory/dimm0/MemoryMetrics",
+        "Id":"Metrics"
+      }
+    )";
+    EXPECT_THAT(exStorer->publishJson(jsonStr), false);
+}
+
+TEST_F(ExternalStorerFileTest, LogServiceNoOdataIdTest)
+{
+    // Try a LogService without @odata.id.
+    std::string jsonStr = R"(
+      {
+        "@odata.type": "#LogService.v1_1_0.LogService","Id":"6F7-C1A7C"
+      }
+    )";
+    EXPECT_THAT(exStorer->publishJson(jsonStr), false);
+}
+
+TEST_F(ExternalStorerFileTest, LogServiceNoIdTest)
+{
+    // Try a LogService without Id.
+    std::string jsonStr = R"(
+      {
+        "@odata.id": "/redfish/v1/Systems/system/LogServices/6F7-C1A7C",
+        "@odata.type": "#LogService.v1_1_0.LogService"
+      }
+    )";
+    EXPECT_THAT(exStorer->publishJson(jsonStr), false);
+}
+
+TEST_F(ExternalStorerFileTest, LogServiceTest)
+{
+    // A valid LogService test.
+    std::string jsonStr = R"(
+      {
+        "@odata.id": "/redfish/v1/Systems/system/LogServices/6F7-C1A7C",
+        "@odata.type": "#LogService.v1_1_0.LogService","Id":"6F7-C1A7C"
+        }
+      )";
+    std::string exServiceFolder =
+        "/some/path/redfish/v1/Systems/system/LogServices/6F7-C1A7C";
+    std::string exEntriesFolder =
+        "/some/path/redfish/v1/Systems/system/LogServices/6F7-C1A7C/Entries";
+    nlohmann::json exEntriesJson = "{}"_json;
+    nlohmann::json exServiceJson = nlohmann::json::parse(jsonStr);
+    EXPECT_CALL(*mockFileWriterPtr, createFile(exServiceFolder, exServiceJson))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*mockFileWriterPtr, createFile(exEntriesFolder, exEntriesJson))
+        .WillOnce(Return(true));
+    EXPECT_THAT(exStorer->publishJson(jsonStr), true);
+}
+
+TEST_F(ExternalStorerFileTest, LogEntryWithoutLogServiceTest)
+{
+    // Try a LogEntry without sending a LogService first.
+    std::string jsonLogEntry = R"(
+      {
+        "@odata.type": "#LogEntry.v1_13_0.LogEntry"
+      }
+    )";
+    EXPECT_THAT(exStorer->publishJson(jsonLogEntry), false);
+}
+
+TEST_F(ExternalStorerFileTest, LogEntryTest)
+{
+    // Before sending a LogEntry, first we need to push a LogService.
+    std::string jsonLogSerivce = R"(
+      {
+        "@odata.id": "/redfish/v1/Systems/system/LogServices/6F7-C1A7C",
+        "@odata.type": "#LogService.v1_1_0.LogService","Id":"6F7-C1A7C"
+      }
+    )";
+    std::string exServiceFolder =
+        "/some/path/redfish/v1/Systems/system/LogServices/6F7-C1A7C";
+    std::string exEntriesFolder =
+        "/some/path/redfish/v1/Systems/system/LogServices/6F7-C1A7C/Entries";
+    nlohmann::json exEntriesJson = "{}"_json;
+    nlohmann::json exServiceJson = nlohmann::json::parse(jsonLogSerivce);
+    EXPECT_CALL(*mockFileWriterPtr, createFile(exServiceFolder, exServiceJson))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*mockFileWriterPtr, createFile(exEntriesFolder, exEntriesJson))
+        .WillOnce(Return(true));
+    EXPECT_THAT(exStorer->publishJson(jsonLogSerivce), true);
+
+    // Now send a LogEntry
+    std::string jsonLogEntry = R"(
+      {
+        "@odata.id": "/some/odata/id",
+        "@odata.type": "#LogEntry.v1_13_0.LogEntry"
+      }
+    )";
+    nlohmann::json logEntryOut;
+    EXPECT_CALL(*mockFileWriterPtr, createFile(_, _))
+        .WillOnce(DoAll(SaveArg<1>(&logEntryOut), Return(true)));
+    EXPECT_THAT(exStorer->publishJson(jsonLogEntry), true);
+    EXPECT_NE(logEntryOut["Id"], nullptr);
+    EXPECT_EQ(logEntryOut["@odata.id"], nullptr);
+}
+
+TEST_F(ExternalStorerFileTest, OtherSchemaNoOdataIdTest)
+{
+    // Try a another PDRs without @odata.id.
+    std::string jsonStr = R"(
+      {
+        "@odata.type": "#MemoryMetrics.v1_4_1.MemoryMetrics",
+        "Id":"Metrics"
+      }
+    )";
+    EXPECT_THAT(exStorer->publishJson(jsonStr), false);
+}
+
+TEST_F(ExternalStorerFileTest, OtherSchemaTypeTest)
+{
+    // A valid MemoryMetrics PDR.
+    std::string jsonStr = R"(
+      {
+        "@odata.id": "/redfish/v1/Systems/system/Memory/dimm0/MemoryMetrics",
+        "@odata.type": "#MemoryMetrics.v1_4_1.MemoryMetrics",
+        "Id": "Metrics"
+      }
+    )";
+    std::string exFolder =
+        "/some/path/redfish/v1/Systems/system/Memory/dimm0/MemoryMetrics";
+    nlohmann::json exJson = nlohmann::json::parse(jsonStr);
+    EXPECT_CALL(*mockFileWriterPtr, createFile(exFolder, exJson))
+        .WillOnce(Return(true));
+    EXPECT_THAT(exStorer->publishJson(jsonStr), true);
+}
+
+} // namespace rde
+} // namespace bios_bmc_smm_error_logger
diff --git a/test/meson.build b/test/meson.build
index 6f72d9f..01a92a2 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -26,6 +26,7 @@
   'pci_handler',
   'rde_dictionary_manager',
   'buffer',
+  'external_storer_file',
 ]
 foreach t : gtests
   test(t, executable(t.underscorify(), t + '_test.cpp',