diff --git a/extensions/openpower-pels/openpower-pels.mk b/extensions/openpower-pels/openpower-pels.mk
index 2cc2393..04106fd 100644
--- a/extensions/openpower-pels/openpower-pels.mk
+++ b/extensions/openpower-pels/openpower-pels.mk
@@ -4,5 +4,6 @@
 	extensions/openpower-pels/log_id.cpp \
 	extensions/openpower-pels/manager.cpp \
 	extensions/openpower-pels/paths.cpp \
+	extensions/openpower-pels/pel.cpp \
 	extensions/openpower-pels/private_header.cpp \
 	extensions/openpower-pels/user_header.cpp
diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
new file mode 100644
index 0000000..3000864
--- /dev/null
+++ b/extensions/openpower-pels/pel.cpp
@@ -0,0 +1,85 @@
+#include "pel.hpp"
+
+#include "bcd_time.hpp"
+#include "log_id.hpp"
+#include "stream.hpp"
+
+namespace openpower
+{
+namespace pels
+{
+
+PEL::PEL(const std::vector<uint8_t>& data) : PEL(data, 0)
+{
+}
+
+PEL::PEL(const std::vector<uint8_t>& data, uint32_t obmcLogID) : _rawPEL(data)
+{
+    populateFromRawData(obmcLogID);
+}
+
+void PEL::populateFromRawData(uint32_t obmcLogID)
+{
+    Stream pelData{_rawPEL};
+    _ph = std::make_unique<PrivateHeader>(pelData);
+    if (obmcLogID != 0)
+    {
+        _ph->obmcLogID() = obmcLogID;
+    }
+
+    _uh = std::make_unique<UserHeader>(pelData);
+}
+
+bool PEL::valid() const
+{
+    bool valid = _ph->valid();
+
+    if (valid)
+    {
+        valid = _uh->valid();
+    }
+
+    return valid;
+}
+
+void PEL::setCommitTime()
+{
+    auto now = std::chrono::system_clock::now();
+    _ph->commitTimestamp() = getBCDTime(now);
+}
+
+void PEL::assignID()
+{
+    _ph->id() = generatePELID();
+}
+
+void PEL::flatten(std::vector<uint8_t>& pelBuffer)
+{
+    Stream pelData{pelBuffer};
+    if (_ph->valid())
+    {
+        pelData << *_ph;
+    }
+    else
+    {
+        return;
+    }
+
+    if (_uh->valid())
+    {
+        pelData << *_uh;
+    }
+}
+
+std::vector<uint8_t> PEL::data()
+{
+    // Until we can recreate a complete PEL from objects, need to just flatten
+    // on top of the original PEL data which we need to keep around for this
+    // reason.
+
+    flatten(_rawPEL);
+    return _rawPEL;
+}
+
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/pel.hpp b/extensions/openpower-pels/pel.hpp
new file mode 100644
index 0000000..564fe33
--- /dev/null
+++ b/extensions/openpower-pels/pel.hpp
@@ -0,0 +1,204 @@
+#pragma once
+
+#include "private_header.hpp"
+#include "user_header.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace openpower
+{
+namespace pels
+{
+
+/** @class PEL
+ *
+ * @brief This class represents a specific event log format referred to as a
+ * Platform Event Log.
+ *
+ * Every field in a PEL are in structures call sections, of which there are
+ * several types.  Some sections are required, and some are optional.  In some
+ * cases there may be more than one instance of a section type.
+ *
+ * The only two required sections for every type of PEL are the Private Header
+ * section and User Header section, which must be in the first and second
+ * positions, respectively.
+ *
+ * Every section starts with an 8 byte section header, which has the section
+ * size and type, among other things.
+ *
+ * This class represents all sections with objects.
+ *
+ * The available constructors are:
+ * - PEL(const std::vector<uint8_t>& data) - build this object out of a fully
+ *   formed flattened PEL.
+ *
+ * The data() method allows one to retrieve the PEL as a vector<uint8_t>.  This
+ * is the format in which it is stored and transmitted.
+ */
+class PEL
+{
+  public:
+    PEL() = delete;
+    ~PEL() = default;
+    PEL(const PEL&) = delete;
+    PEL& operator=(const PEL&) = delete;
+    PEL(PEL&&) = delete;
+    PEL& operator=(PEL&&) = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * Build a PEL from raw data.
+     *
+     * @param[in] data - The PEL data
+     */
+    PEL(const std::vector<uint8_t>& data);
+
+    /**
+     * @brief Constructor
+     *
+     * Build a PEL from the raw data.
+     *
+     * @param[in] data - the PEL data
+     * @param[in] obmcLogID - the corresponding OpenBMC event log ID
+     */
+    PEL(const std::vector<uint8_t>& data, uint32_t obmcLogID);
+
+    /**
+     * @brief Convenience function to return the log ID field from the
+     *        Private Header section.
+     *
+     * @return uint32_t - the ID
+     */
+    uint32_t id() const
+    {
+        return _ph->id();
+    }
+
+    /**
+     * @brief Convenience function to return the PLID field from the
+     *        Private Header section.
+     *
+     * @return uint32_t - the PLID
+     */
+    uint32_t plid() const
+    {
+        return _ph->plid();
+    }
+
+    /**
+     * @brief Convenience function to return the OpenBMC event log ID field
+     * from the Private Header section.
+     *
+     * @return uint32_t - the OpenBMC event log ID
+     */
+    uint32_t obmcLogID() const
+    {
+        return _ph->obmcLogID();
+    }
+
+    /**
+     * @brief Convenience function to return the commit time field from
+     *        the Private Header section.
+     *
+     * @return BCDTime - the timestamp
+     */
+    BCDTime commitTime() const
+    {
+        return _ph->commitTimestamp();
+    }
+
+    /**
+     * @brief Convenience function to return the create time field from
+     *        the Private Header section.
+     *
+     * @return BCDTime - the timestamp
+     */
+    BCDTime createTime() const
+    {
+        return _ph->createTimestamp();
+    }
+
+    /**
+     * @brief Gives access to the Private Header section class
+     *
+     * @return std::unique_ptr<PrivateHeader>& the private header
+     */
+    std::unique_ptr<PrivateHeader>& privateHeader()
+    {
+        return _ph;
+    }
+
+    /**
+     * @brief Gives access to the User Header section class
+     *
+     * @return std::unique_ptr<UserHeader>& the user header
+     */
+    std::unique_ptr<UserHeader>& userHeader()
+    {
+        return _uh;
+    }
+
+    /**
+     * @brief Returns the PEL data.
+     *
+     * @return std::vector<uint8_t> - the raw PEL data
+     */
+    std::vector<uint8_t> data();
+
+    /**
+     * @brief Says if the PEL is valid (the sections are all valid)
+     *
+     * @return bool - if the PEL is valid
+     */
+    bool valid() const;
+
+    /**
+     * @brief Sets the commit timestamp to the current time
+     */
+    void setCommitTime();
+
+    /**
+     * @brief Sets the error log ID field to a unique ID.
+     */
+    void assignID();
+
+  private:
+    /**
+     * @brief Builds the section objects from a PEL data buffer
+     *
+     * @param[in] obmcLogID - The OpenBMC event log ID to use for that
+     *                        field in the Private Header.
+     */
+    void populateFromRawData(uint32_t obmcLogID);
+
+    /**
+     * @brief Flattens the PEL objects into the buffer
+     *
+     * @param[out] pelBuffer - What the data will be written to
+     */
+    void flatten(std::vector<uint8_t>& pelBuffer);
+
+    /**
+     * @brief The PEL Private Header section
+     */
+    std::unique_ptr<PrivateHeader> _ph;
+
+    /**
+     * @brief The PEL User Header section
+     */
+    std::unique_ptr<UserHeader> _uh;
+
+    /**
+     * @brief The PEL itself.
+     *
+     * This should be able to be removed when this class is able to
+     * serialize/deserialize a complete PEL from its objects, as
+     * then there will be no need to keep around the data anymore.
+     */
+    std::vector<uint8_t> _rawPEL;
+};
+
+} // namespace pels
+} // namespace openpower
diff --git a/test/openpower-pels/Makefile.include b/test/openpower-pels/Makefile.include
index 0e0257c..052aa2a 100644
--- a/test/openpower-pels/Makefile.include
+++ b/test/openpower-pels/Makefile.include
@@ -4,6 +4,7 @@
 	additional_data_test \
 	bcd_time_test \
 	log_id_test \
+	pel_test \
 	private_header_test \
 	section_header_test \
 	stream_test \
@@ -11,6 +12,8 @@
 
 pel_objects = \
 	$(top_builddir)/extensions/openpower-pels/bcd_time.o \
+	$(top_builddir)/extensions/openpower-pels/log_id.o \
+	$(top_builddir)/extensions/openpower-pels/pel.o \
 	$(top_builddir)/extensions/openpower-pels/private_header.o \
 	$(top_builddir)/extensions/openpower-pels/user_header.o
 
@@ -43,7 +46,7 @@
 section_header_test_LDFLAGS = $(test_ldflags)
 
 private_header_test_SOURCES = \
-	%reldir%/private_header_test.cpp %reldir%/pel_utils.cpp
+	%reldir%/private_header_test.cpp %reldir%/pel_utils.cpp %reldir%/paths.cpp
 private_header_test_CPPFLAGS = $(test_cppflags)
 private_header_test_CXXFLAGS = $(test_cxxflags)
 private_header_test_LDADD = \
@@ -52,7 +55,7 @@
 private_header_test_LDFLAGS = $(test_ldflags)
 
 user_header_test_SOURCES = \
-	%reldir%/user_header_test.cpp %reldir%/pel_utils.cpp
+	%reldir%/user_header_test.cpp %reldir%/pel_utils.cpp %reldir%/paths.cpp
 user_header_test_CPPFLAGS = $(test_cppflags)
 user_header_test_CXXFLAGS = $(test_cxxflags)
 user_header_test_LDADD = \
@@ -68,3 +71,12 @@
 	$(test_ldadd) \
 	$(top_builddir)/extensions/openpower-pels/log_id.o
 log_id_test_LDFLAGS = $(test_ldflags)
+
+pel_test_SOURCES = \
+	%reldir%/pel_test.cpp %reldir%/paths.cpp %reldir%/pel_utils.cpp
+pel_test_CPPFLAGS = $(test_cppflags)
+pel_test_CXXFLAGS = $(test_cxxflags)
+pel_test_LDADD = \
+	$(test_ldadd) \
+	$(pel_objects)
+pel_test_LDFLAGS = $(test_ldflags)
diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
new file mode 100644
index 0000000..ba71dc2
--- /dev/null
+++ b/test/openpower-pels/pel_test.cpp
@@ -0,0 +1,111 @@
+#include "extensions/openpower-pels/pel.hpp"
+#include "pel_utils.hpp"
+
+#include <filesystem>
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+namespace fs = std::filesystem;
+using namespace openpower::pels;
+
+class PELTest : public CleanLogID
+{
+};
+
+TEST_F(PELTest, FlattenTest)
+{
+    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto pel = std::make_unique<PEL>(*data);
+
+    // Check a few fields
+    EXPECT_TRUE(pel->valid());
+    EXPECT_EQ(pel->id(), 0x80818283);
+    EXPECT_EQ(pel->plid(), 0x50515253);
+    EXPECT_EQ(pel->userHeader()->subsystem(), 0x10);
+    EXPECT_EQ(pel->userHeader()->actionFlags(), 0x80C0);
+
+    // Test that data in == data out
+    auto flattenedData = pel->data();
+    ASSERT_EQ(*data, flattenedData);
+}
+
+TEST_F(PELTest, CommitTimeTest)
+{
+    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto pel = std::make_unique<PEL>(*data);
+
+    auto origTime = pel->commitTime();
+    pel->setCommitTime();
+    auto newTime = pel->commitTime();
+
+    ASSERT_NE(origTime, newTime);
+
+    // Make a new PEL and check new value is still there
+    auto newData = pel->data();
+    auto newPel = std::make_unique<PEL>(newData);
+    ASSERT_EQ(newTime, newPel->commitTime());
+}
+
+TEST_F(PELTest, AssignIDTest)
+{
+    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto pel = std::make_unique<PEL>(*data);
+
+    auto origID = pel->id();
+    pel->assignID();
+    auto newID = pel->id();
+
+    ASSERT_NE(origID, newID);
+
+    // Make a new PEL and check new value is still there
+    auto newData = pel->data();
+    auto newPel = std::make_unique<PEL>(newData);
+    ASSERT_EQ(newID, newPel->id());
+}
+
+TEST_F(PELTest, WithLogIDTest)
+{
+    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto pel = std::make_unique<PEL>(*data, 0x42);
+
+    EXPECT_TRUE(pel->valid());
+    EXPECT_EQ(pel->obmcLogID(), 0x42);
+}
+
+TEST_F(PELTest, InvalidPELTest)
+{
+    auto data = pelDataFactory(TestPelType::pelSimple);
+
+    // Too small
+    data->resize(PrivateHeader::flattenedSize());
+
+    auto pel = std::make_unique<PEL>(*data);
+
+    EXPECT_TRUE(pel->privateHeader()->valid());
+    EXPECT_FALSE(pel->userHeader()->valid());
+    EXPECT_FALSE(pel->valid());
+
+    // Ensure we can still flatten bad data
+    auto newData = pel->data();
+    EXPECT_EQ(*data, newData);
+
+    // Now corrupt the private header
+    data = pelDataFactory(TestPelType::pelSimple);
+    data->at(0) = 0;
+    pel = std::make_unique<PEL>(*data);
+
+    EXPECT_FALSE(pel->privateHeader()->valid());
+    EXPECT_TRUE(pel->userHeader()->valid());
+    EXPECT_FALSE(pel->valid());
+}
+
+TEST_F(PELTest, EmptyDataTest)
+{
+    std::vector<uint8_t> data;
+    auto pel = std::make_unique<PEL>(data);
+
+    EXPECT_FALSE(pel->privateHeader()->valid());
+    EXPECT_FALSE(pel->userHeader()->valid());
+    EXPECT_FALSE(pel->valid());
+}
diff --git a/test/openpower-pels/pel_utils.cpp b/test/openpower-pels/pel_utils.cpp
index b6714eb..4541694 100644
--- a/test/openpower-pels/pel_utils.cpp
+++ b/test/openpower-pels/pel_utils.cpp
@@ -10,6 +10,8 @@
 namespace fs = std::filesystem;
 using namespace openpower::pels;
 
+std::filesystem::path CleanLogID::pelIDFile{};
+
 constexpr uint8_t simplePEL[] = {
     // private header section header
     0x50, 0x48, // ID 'PH'
diff --git a/test/openpower-pels/pel_utils.hpp b/test/openpower-pels/pel_utils.hpp
index 65fa196..7475720 100644
--- a/test/openpower-pels/pel_utils.hpp
+++ b/test/openpower-pels/pel_utils.hpp
@@ -1,3 +1,5 @@
+#include "extensions/openpower-pels/paths.hpp"
+
 #include <filesystem>
 #include <memory>
 #include <vector>
@@ -5,6 +7,26 @@
 #include <gtest/gtest.h>
 
 /**
+ * @brief Test fixture to remove the pelID file that PELs use.
+ */
+class CleanLogID : public ::testing::Test
+{
+  protected:
+    static void SetUpTestCase()
+    {
+        pelIDFile = openpower::pels::getPELIDFile();
+    }
+
+    static void TearDownTestCase()
+    {
+        std::filesystem::remove_all(
+            std::filesystem::path{pelIDFile}.parent_path());
+    }
+
+    static std::filesystem::path pelIDFile;
+};
+
+/**
  * @brief Tells the factory which PEL to create
  */
 enum class TestPelType