diff --git a/extensions/openpower-pels/data_interface.cpp b/extensions/openpower-pels/data_interface.cpp
index 4cad337..de6591a 100644
--- a/extensions/openpower-pels/data_interface.cpp
+++ b/extensions/openpower-pels/data_interface.cpp
@@ -64,8 +64,8 @@
     "xyz.openbmc_project.Inventory.Item.Board.Motherboard";
 constexpr auto viniRecordVPD = "com.ibm.ipzvpd.VINI";
 constexpr auto locCode = "com.ibm.ipzvpd.Location";
-constexpr auto invCompatible =
-    "xyz.openbmc_project.Inventory.Decorator.Compatible";
+constexpr auto compatible =
+    "xyz.openbmc_project.Configuration.IBMCompatibleSystem";
 constexpr auto vpdManager = "com.ibm.VPD.Manager";
 constexpr auto association = "xyz.openbmc_project.Association";
 constexpr auto ledGroup = "xyz.openbmc_project.Led.Group";
@@ -153,13 +153,6 @@
         *this, [this](const auto& value) {
             this->_hostState = std::get<std::string>(value);
         }));
-
-    // Watch the compatible system names property
-    _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
-        bus, object_path::chassisInv, interface::invCompatible, "Names", *this,
-        [this](const auto& value) {
-            this->_systemNames = std::get<std::vector<std::string>>(value);
-        }));
 }
 
 DBusPropertyMap
@@ -444,5 +437,32 @@
     _bus.call(method);
 }
 
+std::vector<std::string> DataInterface::getSystemNames() const
+{
+    DBusSubTree subtree;
+    DBusValue names;
+
+    auto method = _bus.new_method_call(service_name::objectMapper,
+                                       object_path::objectMapper,
+                                       interface::objectMapper, "GetSubTree");
+    method.append(std::string{"/"}, 0,
+                  std::vector<std::string>{interface::compatible});
+    auto reply = _bus.call(method);
+
+    reply.read(subtree);
+    if (subtree.empty())
+    {
+        throw std::runtime_error("Compatible interface not on D-Bus");
+    }
+
+    const auto& object = *(subtree.begin());
+    const auto& path = object.first;
+    const auto& service = object.second.begin()->first;
+
+    getProperty(service, path, interface::compatible, "Names", names);
+
+    return std::get<std::vector<std::string>>(names);
+}
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/data_interface.hpp b/extensions/openpower-pels/data_interface.hpp
index 09bcf59..9a48721 100644
--- a/extensions/openpower-pels/data_interface.hpp
+++ b/extensions/openpower-pels/data_interface.hpp
@@ -239,10 +239,7 @@
      *
      * @return std::vector<std::string> - The list of names
      */
-    virtual const std::vector<std::string>& getSystemNames() const
-    {
-        return _systemNames;
-    }
+    virtual std::vector<std::string> getSystemNames() const = 0;
 
     /**
      * @brief Fills in the placeholder 'Ufcs' in the passed in location
@@ -401,11 +398,6 @@
      * @brief The motherboard CCIN
      */
     std::string _motherboardCCIN;
-
-    /**
-     * @brief The compatible system names array
-     */
-    std::vector<std::string> _systemNames;
 };
 
 /**
@@ -492,6 +484,13 @@
         getLocationCode(const std::string& inventoryPath) const override;
 
     /**
+     * @brief Get the list of system type names the system is called.
+     *
+     * @return std::vector<std::string> - The list of names
+     */
+    std::vector<std::string> getSystemNames() const override;
+
+    /**
      * @brief Fills in the placeholder 'Ufcs' in the passed in location
      *        code with the machine feature code and serial number, which
      *        is needed to create a valid location code.
diff --git a/extensions/openpower-pels/dbus_types.hpp b/extensions/openpower-pels/dbus_types.hpp
index 8743f8f..9532177 100644
--- a/extensions/openpower-pels/dbus_types.hpp
+++ b/extensions/openpower-pels/dbus_types.hpp
@@ -19,5 +19,7 @@
 using DBusPathList = std::vector<DBusPath>;
 using DBusPropertyMap = std::map<DBusProperty, DBusValue>;
 using DBusInterfaceMap = std::map<DBusInterface, DBusPropertyMap>;
+using DBusSubTree =
+    std::map<DBusPath, std::map<DBusService, DBusInterfaceList>>;
 
 } // namespace openpower::pels
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index a687c55..276c506 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -69,24 +69,19 @@
     else
     {
         // Find the severity possibly dependent on the system type.
-        auto sev =
-            getSeverity(entry.severity.value(), dataIface.getSystemNames());
+        auto sev = getSeverity(entry.severity.value(), dataIface);
         if (sev)
         {
             _eventSeverity = *sev;
         }
         else
         {
-            // Someone screwed up the message registry.
+            // Either someone  screwed up the message registry
+            // or getSystemNames failed.
             std::string types;
-            const auto& compatibles = dataIface.getSystemNames();
-            std::for_each(compatibles.begin(), compatibles.end(),
-                          [&types](const auto& t) { types += t + '|'; });
-
             log<level::ERR>(
-                "No severity entry found for this error and system name",
-                phosphor::logging::entry("ERROR=%s", entry.name.c_str()),
-                phosphor::logging::entry("SYSTEMNAMES=%s", types.c_str()));
+                "Failed finding the severity in the message registry",
+                phosphor::logging::entry("ERROR=%s", entry.name.c_str()));
 
             // Have to choose something, just use informational.
             _eventSeverity = 0;
@@ -199,9 +194,27 @@
 
 std::optional<uint8_t> UserHeader::getSeverity(
     const std::vector<message::RegistrySeverity>& severities,
-    const std::vector<std::string>& systemNames) const
+    const DataInterfaceBase& dataIface) const
 {
     const uint8_t* s = nullptr;
+    std::vector<std::string> systemNames;
+
+    // getSystemNames makes D-Bus calls, so only call it if we
+    // know we'll need it because there is a system name in the sev list
+    if (std::any_of(severities.begin(), severities.end(),
+                    [](const auto& sev) { return !sev.system.empty(); }))
+    {
+        try
+        {
+            systemNames = dataIface.getSystemNames();
+        }
+        catch (const std::exception& e)
+        {
+            log<level::ERR>("Failed trying to look up system names on D-Bus",
+                            entry("ERROR=%s", e.what()));
+            return std::nullopt;
+        }
+    }
 
     // Find the severity to use for this system type, or use the default
     // entry (where no system type is specified).
diff --git a/extensions/openpower-pels/user_header.hpp b/extensions/openpower-pels/user_header.hpp
index 07b74ae..da9be6c 100644
--- a/extensions/openpower-pels/user_header.hpp
+++ b/extensions/openpower-pels/user_header.hpp
@@ -245,11 +245,12 @@
      *
      * @param[in] severities - The array of {systype, severity}
      *                         structures to find an entry in.
-     * @param[in] systemNames - List of compatible system type names
+     * @param[in] dataIface - The DataInterface object
      */
     std::optional<uint8_t>
         getSeverity(const std::vector<message::RegistrySeverity>& severities,
-                    const std::vector<std::string>& systemNames) const;
+                    const DataInterfaceBase& dataIface) const;
+
     /**
      * @brief The subsystem associated with the event.
      */
diff --git a/test/openpower-pels/mocks.hpp b/test/openpower-pels/mocks.hpp
index e9d9fdf..510974c 100644
--- a/test/openpower-pels/mocks.hpp
+++ b/test/openpower-pels/mocks.hpp
@@ -34,8 +34,7 @@
                 (const override));
     MOCK_METHOD(std::string, getLocationCode, (const std::string&),
                 (const override));
-    MOCK_METHOD(const std::vector<std::string>&, getSystemNames, (),
-                (const override));
+    MOCK_METHOD(std::vector<std::string>, getSystemNames, (), (const override));
     MOCK_METHOD(std::string, expandLocationCode, (const std::string&, uint16_t),
                 (const override));
     MOCK_METHOD(std::string, getInventoryFromLocCode,
diff --git a/test/openpower-pels/pel_manager_test.cpp b/test/openpower-pels/pel_manager_test.cpp
index 2247a71..3112a16 100644
--- a/test/openpower-pels/pel_manager_test.cpp
+++ b/test/openpower-pels/pel_manager_test.cpp
@@ -30,7 +30,6 @@
 
 using ::testing::NiceMock;
 using ::testing::Return;
-using ::testing::ReturnRef;
 
 class TestLogger
 {
@@ -883,7 +882,7 @@
         std::vector<std::string> names{"systemA"};
         EXPECT_CALL(*mockIface, getSystemNames)
             .Times(1)
-            .WillOnce(ReturnRef(names));
+            .WillOnce(Return(names));
 
         EXPECT_CALL(*mockIface, expandLocationCode("P42-C23", 0))
             .WillOnce(Return("U42-P42-C23"));
diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index e1697ac..3631b50 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -29,7 +29,6 @@
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::SetArgReferee;
 
 class PELTest : public CleanLogID
@@ -823,7 +822,7 @@
     std::vector<std::string> names{"systemA"};
     EXPECT_CALL(dataIface, getSystemNames)
         .Times(2)
-        .WillRepeatedly(ReturnRef(names));
+        .WillRepeatedly(Return(names));
 
     EXPECT_CALL(dataIface,
                 getLocationCode(
diff --git a/test/openpower-pels/src_test.cpp b/test/openpower-pels/src_test.cpp
index f439bfc..1f0db2a 100644
--- a/test/openpower-pels/src_test.cpp
+++ b/test/openpower-pels/src_test.cpp
@@ -26,7 +26,6 @@
 using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::SetArgReferee;
 using ::testing::Throw;
 namespace fs = std::filesystem;
@@ -537,7 +536,7 @@
         NiceMock<MockDataInterface> dataIface;
         std::vector<std::string> names{"systemA"};
 
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
+        EXPECT_CALL(dataIface, getSystemNames).WillOnce(Return(names));
 
         SRC src{entry, ad, dataIface};
 
@@ -574,7 +573,7 @@
         std::vector<std::string> names{"systemB"};
 
         EXPECT_CALL(dataIface, expandLocationCode).WillOnce(Return("P0-C8"));
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
+        EXPECT_CALL(dataIface, getSystemNames).WillOnce(Return(names));
 
         SRC src{entry, ad, dataIface};
 
@@ -611,7 +610,7 @@
         NiceMock<MockDataInterface> dataIface;
         std::vector<std::string> names{"systemC"};
 
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
+        EXPECT_CALL(dataIface, getSystemNames).WillOnce(Return(names));
 
         EXPECT_CALL(dataIface, expandLocationCode("P0-C8", 0))
             .WillOnce(Return("UXXX-P0-C8"));
@@ -707,7 +706,7 @@
         NiceMock<MockDataInterface> dataIface;
         std::vector<std::string> names{"systemA"};
 
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
+        EXPECT_CALL(dataIface, getSystemNames).WillOnce(Return(names));
 
         EXPECT_CALL(dataIface, getLocationCode("motherboard"))
             .Times(1)
@@ -760,7 +759,7 @@
         NiceMock<MockDataInterface> dataIface;
         std::vector<std::string> names{"systemA"};
 
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
+        EXPECT_CALL(dataIface, getSystemNames).WillOnce(Return(names));
 
         SRC src{entry, ad, dataIface};
 
@@ -825,7 +824,7 @@
 
     EXPECT_CALL(dataIface, getSystemNames)
         .Times(5)
-        .WillRepeatedly(ReturnRef(names));
+        .WillRepeatedly(Return(names));
 
     EXPECT_CALL(dataIface, getInventoryFromLocCode("P1-C40", 0, false))
         .Times(3)
diff --git a/test/openpower-pels/user_header_test.cpp b/test/openpower-pels/user_header_test.cpp
index 526a59e..b7b6583 100644
--- a/test/openpower-pels/user_header_test.cpp
+++ b/test/openpower-pels/user_header_test.cpp
@@ -24,7 +24,6 @@
 
 using namespace openpower::pels;
 using ::testing::Return;
-using ::testing::ReturnRef;
 
 TEST(UserHeaderTest, SizeTest)
 {
@@ -113,9 +112,6 @@
         regEntry.eventScope = 2;
 
         MockDataInterface dataIface;
-        std::vector<std::string> names{"systemA"};
-
-        EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
 
         UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
                       dataIface);
@@ -140,8 +136,6 @@
             // The same thing, but as if the action flags weren't specified
             // in the registry so they are a nullopt.  The object should
             // then set them to 0xFFFF.
-            EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
-
             regEntry.actionFlags = std::nullopt;
 
             UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
@@ -164,9 +158,9 @@
         std::vector<std::string> names3{"systemC"};
 
         EXPECT_CALL(dataIface, getSystemNames)
-            .WillOnce(ReturnRef(names1))
-            .WillOnce(ReturnRef(names2))
-            .WillOnce(ReturnRef(names3));
+            .WillOnce(Return(names1))
+            .WillOnce(Return(names2))
+            .WillOnce(Return(names3));
 
         {
             UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
@@ -224,9 +218,6 @@
 
     MockDataInterface dataIface;
 
-    std::vector<std::string> names{"systemA"};
-    EXPECT_CALL(dataIface, getSystemNames).WillOnce(ReturnRef(names));
-
     UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, dataIface);
 
     ASSERT_EQ(uh.eventType(), 0);