diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp
index 4dc1f0b..05b286a 100644
--- a/extensions/openpower-pels/registry.cpp
+++ b/extensions/openpower-pels/registry.cpp
@@ -21,6 +21,7 @@
 
 #include <phosphor-logging/lg2.hpp>
 
+#include <algorithm>
 #include <fstream>
 
 namespace openpower
@@ -330,10 +331,19 @@
  * @brief Finds the callouts to use when there is no AdditionalData,
  *        but the system type may be used as a key.
  *
- * One entry in the array looks like the following.  The System key
- * is optional and if not present it means that entry applies to
- * every configuration that doesn't have another entry with a matching
- * System key.
+ * A sample calloutList array looks like the following.  The System and Systems
+ * key are optional.
+ *
+ * System key - Value of the key will be the system name as a string. The
+ * callouts for a specific system can define under this key.
+ *
+ * Systems key - Value of the key will be an array of system names in the form
+ * of string. The callouts common to the systems mentioned in the array can
+ * define under this key.
+ *
+ * If both System and Systems not present it means that entry applies to every
+ * configuration that doesn't have another entry with a matching System and
+ * Systems key.
  *
  *    {
  *        "System": "system1",
@@ -348,42 +358,85 @@
  *                "LocCode": "P1"
  *            }
  *        ]
+ *    },
+ *    {
+ *        "Systems": ["system1", 'system2"],
+ *        "CalloutList":
+ *        [
+ *            {
+ *                "Priority": "high",
+ *                "LocCode": "P0-C1"
+ *            },
+ *            {
+ *                "Priority": "low",
+ *                "LocCode": "P0"
+ *            }
+ *        ]
  *    }
+ *
+ * @param[in] json - The callout JSON
+ * @param[in] systemNames - List of compatible system type names
+ * @param[out] calloutLists - The JSON array which will hold the calloutlist to
+ * use specific to the system.
+ *
+ * @return - Throws runtime exception if json is not an array or if calloutLists
+ *           is empty.
  */
-const nlohmann::json&
-    findCalloutList(const nlohmann::json& json,
-                    const std::vector<std::string>& systemNames)
+static void findCalloutList(const nlohmann::json& json,
+                            const std::vector<std::string>& systemNames,
+                            nlohmann::json& calloutLists)
 {
-    const nlohmann::json* callouts = nullptr;
-
     if (!json.is_array())
     {
         throw std::runtime_error{"findCalloutList was not passed a JSON array"};
     }
 
-    // The entry with the system type match will take precedence over the entry
-    // without any "System" field in it at all, which will match all other
-    // cases.
-    for (const auto& calloutList : json)
+    // Flag to indicate whether system specific callouts found or not
+    bool foundCallouts = false;
+
+    for (const auto& callouts : json)
     {
-        if (calloutList.contains("System"))
+        if (callouts.contains("System"))
         {
-            if (std::find(systemNames.begin(), systemNames.end(),
-                          calloutList["System"].get<std::string>()) !=
+            if (std::ranges::find(systemNames,
+                                  callouts["System"].get<std::string>()) !=
                 systemNames.end())
             {
-                callouts = &calloutList["CalloutList"];
-                break;
+                calloutLists.insert(calloutLists.end(),
+                                    callouts["CalloutList"].begin(),
+                                    callouts["CalloutList"].end());
+                foundCallouts = true;
             }
+            continue;
         }
-        else
+
+        if (callouts.contains("Systems"))
         {
-            // Any entry with no System key
-            callouts = &calloutList["CalloutList"];
+            std::vector<std::string> systems =
+                callouts["Systems"].get<std::vector<std::string>>();
+            auto inSystemNames = [systemNames](const auto& system) {
+                return (std::ranges::find(systemNames, system) !=
+                        systemNames.end());
+            };
+            if (std::ranges::any_of(systems, inSystemNames))
+            {
+                calloutLists.insert(calloutLists.end(),
+                                    callouts["CalloutList"].begin(),
+                                    callouts["CalloutList"].end());
+                foundCallouts = true;
+            }
+            continue;
+        }
+
+        // Any entry if neither System/Systems key matches with system name
+        if (!foundCallouts)
+        {
+            calloutLists.insert(calloutLists.end(),
+                                callouts["CalloutList"].begin(),
+                                callouts["CalloutList"].end());
         }
     }
-
-    if (!callouts)
+    if (calloutLists.empty())
     {
         std::string types;
         std::for_each(systemNames.begin(), systemNames.end(),
@@ -396,8 +449,6 @@
         throw std::runtime_error{
             "Could not find a CalloutList JSON for this error and system name"};
     }
-
-    return *callouts;
 }
 
 /**
@@ -464,18 +515,34 @@
  *       everything.
  *
  * The JSON looks like:
- *    [
- *        {
- *            "System": "systemA",
- *            "CalloutList":
- *            [
- *                {
- *                    "Priority": "high",
- *                    "LocCode": "P1-C5"
- *                }
- *            ]
- *         }
- *    ]
+ *    {
+ *        "System": "system1",
+ *        "CalloutList":
+ *        [
+ *            {
+ *                "Priority": "high",
+ *                "LocCode": "P1-C1"
+ *            },
+ *            {
+ *                "Priority": "low",
+ *                "LocCode": "P1"
+ *            }
+ *        ]
+ *    },
+ *    {
+ *        "Systems": ["system1", 'system2"],
+ *        "CalloutList":
+ *        [
+ *            {
+ *                "Priority": "high",
+ *                "LocCode": "P0-C1"
+ *            },
+ *            {
+ *                "Priority": "low",
+ *                "LocCode": "P0"
+ *            }
+ *        ]
+ *    }
  *
  * @param[in] json - The callout JSON
  * @param[in] systemNames - List of compatible system type names
@@ -488,11 +555,13 @@
 {
     std::vector<RegistryCallout> calloutEntries;
 
+    nlohmann::json calloutLists = nlohmann::json::array();
+
     // Find the CalloutList to use based on the system type
-    const auto& calloutList = findCalloutList(json, systemNames);
+    findCalloutList(json, systemNames, calloutLists);
 
     // We finally found the callouts, make the objects.
-    for (const auto& callout : calloutList)
+    for (const auto& callout : calloutLists)
     {
         calloutEntries.push_back(std::move(makeRegistryCallout(callout)));
     }
diff --git a/extensions/openpower-pels/registry/README.md b/extensions/openpower-pels/registry/README.md
index 1955ad8..27c0044 100644
--- a/extensions/openpower-pels/registry/README.md
+++ b/extensions/openpower-pels/registry/README.md
@@ -329,6 +329,16 @@
 
 There is room for up to 10 callouts in a PEL.
 
+The callouts based on system type can be added in two ways, by using either a
+key called `System` or by `Systems`.
+
+The `System` key will accept the system name as a string and the user can add
+the callouts specific to that system under the `System`.
+
+Suppose if multiple systems have same callouts, the `Systems` key can be used.
+The `Systems` can accept the system names as an array of strings and the list of
+callouts common to those systems can be listed under the key.
+
 Available maintenance procedures are listed [here][1] and in the source code
 [here][2].
 
@@ -373,10 +383,61 @@
 
 ```
 
-The above example shows that on system 'system1', the FRU at location P1-C1 will
+The above example shows that on system `system1`, the FRU at location P1-C1 will
 be called out with a priority of high, and the FRU at P1 with a priority of low.
 On every other system, the maintenance procedure BMC0002 is called out.
 
+#### Callouts example based on the Systems type
+
+```json
+"Callouts":
+[
+    {
+        "Systems": ["system1", "system2"],
+        "CalloutList":
+        [
+            {
+                "Priority": "high",
+                "LocCode": "P1-C1"
+            },
+            {
+                "Priority": "low",
+                "LocCode": "P1"
+            }
+        ]
+    },
+    {
+        "System": "system1",
+        "CalloutList":
+        [
+            {
+                "Priority": "low",
+                "SymbolicFRU": "service_docs"
+            },
+            {
+                "Priority": "low",
+                "SymbolicFRUTrusted": "air_mover",
+                "UseInventoryLocCode": true
+            }
+        ]
+    },
+    {
+        "CalloutList":
+        [
+            {
+                "Priority": "medium",
+                "Procedure": "BMC0001"
+            }
+        ]
+    }
+]
+```
+
+The above example shows that on `system1`, the FRU at location P1-C1, P1,
+service_docs and air_mover will be called out. For `system2`, the FRU at
+location P1-C1, P1 will be called out. On every other system, the maintenance
+procedure BMC0001 is called out.
+
 #### Callouts example based on an AdditionalData field
 
 ```json
diff --git a/extensions/openpower-pels/registry/schema/schema.json b/extensions/openpower-pels/registry/schema/schema.json
index 429d3bf..d4fea9d 100644
--- a/extensions/openpower-pels/registry/schema/schema.json
+++ b/extensions/openpower-pels/registry/schema/schema.json
@@ -642,6 +642,15 @@
             "minLength": 1
         },
 
+        "systems": {
+            "description": "The Systems key can be defined and can be used to keep the name of the systems as an array of string if the systems possess same callout list.",
+            "type": "array",
+            "items": {
+                "type": "string"
+            },
+            "minItems": 1
+        },
+
         "callouts": {
             "description": "This contains callouts that can vary based on system type.  Each entry contains an optional System property and a required CalloutList property.  If the System property is left out it indicates that the CalloutList callouts are valid for every system type, unless there is another Callouts entry that has a matching System property, in which case that entry is valid.",
             "type": "array",
@@ -650,11 +659,22 @@
 
                 "properties": {
                     "System": { "$ref": "#/definitions/system" },
+                    "Systems": { "$ref": "#/definitions/systems" },
                     "CalloutList": { "$ref": "#/definitions/calloutList" }
                 },
-                "required": ["CalloutList"],
                 "additionalProperties": false
             },
+            "anyOf": [
+                {
+                    "required": ["System", "CalloutList"]
+                },
+                {
+                    "required": ["Systems", "CalloutList"]
+                },
+                {
+                    "required": ["CalloutList"]
+                }
+            ],
             "minItems": 1,
             "maxItems": 10,
 
@@ -665,6 +685,10 @@
                         "CalloutList": [{ "Priority": "high", "LocCode": "P1" }]
                     },
                     {
+                        "Systems": ["system1", "system2"],
+                        "CalloutList": [{ "Priority": "low", "LocCode": "P2" }]
+                    },
+                    {
                         "CalloutList": [
                             { "Priority": "high", "Procedure": "NEXTLVL" }
                         ]