diff --git a/phosphor-power-sequencer/src/config_file_parser.cpp b/phosphor-power-sequencer/src/config_file_parser.cpp
index 2a5cc26..07a92c3 100644
--- a/phosphor-power-sequencer/src/config_file_parser.cpp
+++ b/phosphor-power-sequencer/src/config_file_parser.cpp
@@ -17,6 +17,7 @@
 #include "config_file_parser.hpp"
 
 #include "config_file_parser_error.hpp"
+#include "gpios_only_device.hpp"
 #include "json_parser_utils.hpp"
 #include "ucd90160_device.hpp"
 #include "ucd90320_device.hpp"
@@ -333,11 +334,19 @@
     std::string type = parseString(typeElement, false, variables);
     ++propertyCount;
 
-    // Required i2c_interface property
-    const json& i2cInterfaceElement =
-        getRequiredProperty(element, "i2c_interface");
-    auto [bus, address] = parseI2CInterface(i2cInterfaceElement, variables);
-    ++propertyCount;
+    // i2c_interface property is required for some device types
+    uint8_t bus{0};
+    uint16_t address{0};
+    auto i2cInterfaceIt = element.find("i2c_interface");
+    if (i2cInterfaceIt != element.end())
+    {
+        std::tie(bus, address) = parseI2CInterface(*i2cInterfaceIt, variables);
+        ++propertyCount;
+    }
+    else if (type != GPIOsOnlyDevice::deviceName)
+    {
+        throw std::invalid_argument{"Required property missing: i2c_interface"};
+    }
 
     // Required power_control_gpio_name property
     const json& powerControlGPIONameElement =
@@ -353,11 +362,18 @@
         parseString(powerGoodGPIONameElement, false, variables);
     ++propertyCount;
 
-    // Required rails property
-    const json& railsElement = getRequiredProperty(element, "rails");
-    std::vector<std::unique_ptr<Rail>> rails =
-        parseRailArray(railsElement, variables);
-    ++propertyCount;
+    // rails property is required for some device types
+    std::vector<std::unique_ptr<Rail>> rails{};
+    auto railsIt = element.find("rails");
+    if (railsIt != element.end())
+    {
+        rails = parseRailArray(*railsIt, variables);
+        ++propertyCount;
+    }
+    else if (type != GPIOsOnlyDevice::deviceName)
+    {
+        throw std::invalid_argument{"Required property missing: rails"};
+    }
 
     // Verify no invalid properties exist
     verifyPropertyCount(element, propertyCount);
@@ -374,6 +390,11 @@
             bus, address, powerControlGPIOName, powerGoodGPIOName,
             std::move(rails), services);
     }
+    else if (type == GPIOsOnlyDevice::deviceName)
+    {
+        return std::make_unique<GPIOsOnlyDevice>(powerControlGPIOName,
+                                                 powerGoodGPIOName);
+    }
     throw std::invalid_argument{"Invalid power sequencer type: " + type};
 }
 
diff --git a/phosphor-power-sequencer/src/gpios_only_device.hpp b/phosphor-power-sequencer/src/gpios_only_device.hpp
new file mode 100644
index 0000000..36dc6f2
--- /dev/null
+++ b/phosphor-power-sequencer/src/gpios_only_device.hpp
@@ -0,0 +1,168 @@
+/**
+ * Copyright © 2025 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "power_sequencer_device.hpp"
+#include "rail.hpp"
+#include "services.hpp"
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace phosphor::power::sequencer
+{
+
+/**
+ * @class GPIOsOnlyDevice
+ *
+ * PowerSequencerDevice sub-class that only uses the named GPIOs.
+ *
+ * This class uses named GPIOs to power the device on/off and read the power
+ * good signal from the device.
+ *
+ * No other communication is performed to the device over I2C or through a
+ * device driver. If a pgood fault occurs, no attempt will be made to determine
+ * which voltage rail caused the fault.
+ *
+ * This device type is useful for simple systems that do not require pgood fault
+ * isolation. It is also useful as a temporary solution when performing early
+ * bring-up work on a new system.
+ */
+class GPIOsOnlyDevice : public PowerSequencerDevice
+{
+  public:
+    GPIOsOnlyDevice() = delete;
+    GPIOsOnlyDevice(const GPIOsOnlyDevice&) = delete;
+    GPIOsOnlyDevice(GPIOsOnlyDevice&&) = delete;
+    GPIOsOnlyDevice& operator=(const GPIOsOnlyDevice&) = delete;
+    GPIOsOnlyDevice& operator=(GPIOsOnlyDevice&&) = delete;
+    virtual ~GPIOsOnlyDevice() = default;
+
+    /**
+     * Constructor.
+     *
+     * @param powerControlGPIOName name of the GPIO that turns this device on
+     *                             and off
+     * @param powerGoodGPIOName name of the GPIO that reads the power good
+     *                          signal from this device
+     */
+    explicit GPIOsOnlyDevice(const std::string& powerControlGPIOName,
+                             const std::string& powerGoodGPIOName) :
+        powerControlGPIOName{powerControlGPIOName},
+        powerGoodGPIOName{powerGoodGPIOName}
+    {}
+
+    /** @copydoc PowerSequencerDevice::getName() */
+    virtual const std::string& getName() const override
+    {
+        return deviceName;
+    }
+
+    /** @copydoc PowerSequencerDevice::getBus() */
+    virtual uint8_t getBus() const override
+    {
+        return 0;
+    }
+
+    /** @copydoc PowerSequencerDevice::getAddress() */
+    virtual uint16_t getAddress() const override
+    {
+        return 0;
+    }
+
+    /** @copydoc PowerSequencerDevice::getPowerControlGPIOName() */
+    virtual const std::string& getPowerControlGPIOName() const override
+    {
+        return powerControlGPIOName;
+    }
+
+    /** @copydoc PowerSequencerDevice::getPowerGoodGPIOName() */
+    virtual const std::string& getPowerGoodGPIOName() const override
+    {
+        return powerGoodGPIOName;
+    }
+
+    /** @copydoc PowerSequencerDevice::getRails() */
+    virtual const std::vector<std::unique_ptr<Rail>>& getRails() const override
+    {
+        return rails;
+    }
+
+    /** @copydoc PowerSequencerDevice::getGPIOValues() */
+    virtual std::vector<int> getGPIOValues(
+        [[maybe_unused]] Services& services) override
+    {
+        throw std::logic_error{"getGPIOValues() is not supported"};
+    }
+
+    /** @copydoc PowerSequencerDevice::getStatusWord() */
+    virtual uint16_t getStatusWord([[maybe_unused]] uint8_t page) override
+    {
+        throw std::logic_error{"getStatusWord() is not supported"};
+    }
+
+    /** @copydoc PowerSequencerDevice::getStatusVout() */
+    virtual uint8_t getStatusVout([[maybe_unused]] uint8_t page) override
+    {
+        throw std::logic_error{"getStatusVout() is not supported"};
+    }
+
+    /** @copydoc PowerSequencerDevice::getReadVout() */
+    virtual double getReadVout([[maybe_unused]] uint8_t page) override
+    {
+        throw std::logic_error{"getReadVout() is not supported"};
+    }
+
+    /** @copydoc PowerSequencerDevice::getVoutUVFaultLimit() */
+    virtual double getVoutUVFaultLimit([[maybe_unused]] uint8_t page) override
+    {
+        throw std::logic_error{"getVoutUVFaultLimit() is not supported"};
+    }
+
+    /** @copydoc PowerSequencerDevice::findPgoodFault() */
+    virtual std::string findPgoodFault(
+        [[maybe_unused]] Services& services,
+        [[maybe_unused]] const std::string& powerSupplyError,
+        [[maybe_unused]] std::map<std::string, std::string>& additionalData)
+        override
+    {
+        return std::string{};
+    }
+
+    inline static const std::string deviceName{"gpios_only_device"};
+
+  protected:
+    /**
+     * Name of the GPIO that turns this device on and off.
+     */
+    std::string powerControlGPIOName{};
+
+    /**
+     * Name of the GPIO that reads the power good signal from this device.
+     */
+    std::string powerGoodGPIOName{};
+
+    /**
+     * Empty list of voltage rails to return from getRails().
+     */
+    std::vector<std::unique_ptr<Rail>> rails{};
+};
+
+} // namespace phosphor::power::sequencer