diff --git a/control/json/config_base.hpp b/control/json/config_base.hpp
index 36a4b2c..3184cb5 100644
--- a/control/json/config_base.hpp
+++ b/control/json/config_base.hpp
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include "types.hpp"
+
 #include <nlohmann/json.hpp>
 #include <phosphor-logging/log.hpp>
 
@@ -55,6 +57,47 @@
         return _name;
     }
 
+  protected:
+    /**
+     * @brief Determines the data type of a JSON configured parameter that is
+     * used as a variant within the fan control application and returns the
+     * value as that variant.
+     * @details Retrieves a JSON object by the first derived data type that
+     * is not null. Expected data types should appear in a logical order of
+     * conversion. i.e.) uint and int could both be uint
+     *
+     * @param[in] object - A single JSON object
+     *
+     * @return A `PropertyVariantType` variant containing the JSON object's
+     * value
+     */
+    static const PropertyVariantType getJsonValue(const json& object)
+    {
+        if (auto boolPtr = object.get_ptr<const bool*>())
+        {
+            return *boolPtr;
+        }
+        if (auto intPtr = object.get_ptr<const int64_t*>())
+        {
+            return *intPtr;
+        }
+        if (auto doublePtr = object.get_ptr<const double*>())
+        {
+            return *doublePtr;
+        }
+        if (auto stringPtr = object.get_ptr<const std::string*>())
+        {
+            return *stringPtr;
+        }
+
+        log<level::ERR>(
+            "Unsupported data type for JSON object's value",
+            entry("JSON_ENTRY=%s", object.dump().c_str()),
+            entry("SUPPORTED_TYPES=%s", "{bool, int, double, string}"));
+        throw std::runtime_error(
+            "Unsupported data type for JSON object's value");
+    }
+
   private:
     /* Name of the configuration object */
     std::string _name;
diff --git a/control/json/profile.cpp b/control/json/profile.cpp
index f7f80b1..696716e 100644
--- a/control/json/profile.cpp
+++ b/control/json/profile.cpp
@@ -15,18 +15,94 @@
  */
 #include "profile.hpp"
 
+#include "sdbusplus.hpp"
+
 #include <nlohmann/json.hpp>
 #include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
 
+#include <algorithm>
+#include <iterator>
+#include <numeric>
+
 namespace phosphor::fan::control::json
 {
 
 using json = nlohmann::json;
 using namespace phosphor::logging;
 
+// String key must be in all lowercase for method lookup
+const std::map<std::string, methodHandler> Profile::_methods = {
+    {"all_of", Profile::allOf}};
+
 Profile::Profile(sdbusplus::bus::bus& bus, const json& jsonObj) :
-    ConfigBase(jsonObj), _bus(bus)
-{}
+    ConfigBase(jsonObj), _bus(bus), _active(false)
+{
+    setActive(jsonObj);
+}
+
+void Profile::setActive(const json& jsonObj)
+{
+    if (!jsonObj.contains("method") || !jsonObj["method"].contains("name"))
+    {
+        // Log error on missing profile method
+        log<level::ERR>("Missing required profile method",
+                        entry("JSON=%s", jsonObj.dump().c_str()));
+        throw std::runtime_error("Missing required profile method");
+    }
+    // The method to use in determining if the profile is active
+    auto method = jsonObj["method"]["name"].get<std::string>();
+    std::transform(method.begin(), method.end(), method.begin(), tolower);
+    auto handler = _methods.find(method);
+    if (handler != _methods.end())
+    {
+        // Call method for determining profile's active state
+        _active = handler->second(jsonObj["method"]);
+    }
+    else
+    {
+        // Construct list of available methods
+        auto methods = std::accumulate(
+            std::next(_methods.begin()), _methods.end(),
+            _methods.begin()->first, [](auto list, auto method) {
+                return std::move(list) + ", " + method.first;
+            });
+        log<level::ERR>("Configured method not available",
+                        entry("JSON=%s", jsonObj["method"].dump().c_str()),
+                        entry("METHODS_AVAILABLE=%s", methods.c_str()));
+    }
+}
+
+bool Profile::allOf(const json& method)
+{
+    if (!method.contains("properties"))
+    {
+        log<level::ERR>("Missing required all_of method properties list",
+                        entry("JSON=%s", method.dump().c_str()));
+        throw std::runtime_error(
+            "Missing required all_of method properties list");
+    }
+
+    return std::all_of(
+        method["properties"].begin(), method["properties"].end(),
+        [](const json& obj) {
+            if (!obj.contains("path") || !obj.contains("interface") ||
+                !obj.contains("property") || !obj.contains("value"))
+            {
+                log<level::ERR>(
+                    "Missing required all_of method property parameters",
+                    entry("JSON=%s", obj.dump().c_str()));
+                throw std::runtime_error(
+                    "Missing required all_of method parameters");
+            }
+            auto variant =
+                util::SDBusPlus::getPropertyVariant<PropertyVariantType>(
+                    obj["path"].get<std::string>(),
+                    obj["interface"].get<std::string>(),
+                    obj["property"].get<std::string>());
+
+            return getJsonValue(obj["value"]) == variant;
+        });
+}
 
 } // namespace phosphor::fan::control::json
diff --git a/control/json/profile.hpp b/control/json/profile.hpp
index ed80226..eacb1dc 100644
--- a/control/json/profile.hpp
+++ b/control/json/profile.hpp
@@ -24,6 +24,7 @@
 {
 
 using json = nlohmann::json;
+using methodHandler = std::function<bool(const json&)>;
 
 /**
  * @class Profile - Represents a configured fan control profile
@@ -58,9 +59,56 @@
      */
     Profile(sdbusplus::bus::bus& bus, const json& jsonObj);
 
+    /**
+     * @brief Get the active state
+     *
+     * @return The active state of the profile
+     */
+    inline bool isActive() const
+    {
+        return _active;
+    }
+
   private:
     /* The sdbusplus bus object */
     sdbusplus::bus::bus& _bus;
+
+    /* Active state of the profile */
+    bool _active;
+
+    /* Supported methods to their corresponding handler functions */
+    static const std::map<std::string, methodHandler> _methods;
+
+    /**
+     * @brief Parse and set the profile's active state
+     *
+     * @param[in] jsonObj - JSON object for the profile
+     *
+     * Sets the active state of the profile using the configured method of
+     * determining its active state.
+     */
+    void setActive(const json& jsonObj);
+
+    /**
+     * @brief An active state method where all must be true
+     *
+     * @param[in] method - JSON for the profile's method
+     *
+     * Active state method that takes a list of configured dbus properties where
+     * all of those properties must equal their configured values to set the
+     * profile to be active.
+     *
+     * "name": "all_of",
+     * "properties": [
+     *     {
+     *         "path": "[DBUS PATH]",
+     *         "interface": "[DBUS INTERFACE]",
+     *         "property": "[DBUS PROPERTY]",
+     *         "value": [VALUE TO BE ACTIVE]
+     *     }
+     * ]
+     */
+    static bool allOf(const json& method);
 };
 
 } // namespace phosphor::fan::control::json