diff --git a/plugins/XmlMaterialProfile/XmlMaterialProfile.py b/plugins/XmlMaterialProfile/XmlMaterialProfile.py
index e8d0c9d2f0..bbf5dfe2ba 100644
--- a/plugins/XmlMaterialProfile/XmlMaterialProfile.py
+++ b/plugins/XmlMaterialProfile/XmlMaterialProfile.py
@@ -205,7 +205,7 @@ class XmlMaterialProfile(InstanceContainer):
                 self._addSettingElement(builder, instance)
 
         machine_container_map = {}
-        machine_nozzle_map = {}
+        machine_variant_map = {}
 
         variant_manager = CuraApplication.getInstance().getVariantManager()
         material_manager = CuraApplication.getInstance().getMaterialManager()
@@ -225,13 +225,14 @@ class XmlMaterialProfile(InstanceContainer):
             if definition_id not in machine_container_map:
                 machine_container_map[definition_id] = container
 
-            if definition_id not in machine_nozzle_map:
-                machine_nozzle_map[definition_id] = {}
+            if definition_id not in machine_variant_map:
+                machine_variant_map[definition_id] = {}
 
             variant_name = container.getMetaDataEntry("variant_name")
             if variant_name:
-                machine_nozzle_map[definition_id][variant_name] = variant_manager.getVariantNode(definition_id,
-                                                                                                 variant_name)
+                variant_dict = {"variant_node": variant_manager.getVariantNode(definition_id, variant_name),
+                                "material_container": container}
+                machine_variant_map[definition_id][variant_name] = variant_dict
                 continue
 
             machine_container_map[definition_id] = container
@@ -265,28 +266,60 @@ class XmlMaterialProfile(InstanceContainer):
                 self._addSettingElement(builder, instance)
 
             # Find all hotend sub-profiles corresponding to this material and machine and add them to this profile.
-            for hotend_name, variant_node in machine_nozzle_map[definition_id].items():
-                # The hotend identifier is not the containers name, but its "name".
-                builder.start("hotend", {"id": hotend_name})
+            buildplate_dict = {}
+            for variant_name, variant_dict in machine_variant_map[definition_id].items():
+                variant_type = variant_dict["variant_node"].metadata["hardware_type"]
+                from cura.Machines.VariantManager import VariantType
+                variant_type = VariantType(variant_type)
+                if variant_type == VariantType.NOZZLE:
+                    # The hotend identifier is not the containers name, but its "name".
+                    builder.start("hotend", {"id": variant_name})
 
-                # Compatible is a special case, as it's added as a meta data entry (instead of an instance).
-                compatible = variant_node.metadata.get("compatible")
-                if compatible is not None:
-                    builder.start("setting", {"key": "hardware compatible"})
-                    if compatible:
-                        builder.data("yes")
-                    else:
-                        builder.data("no")
-                    builder.end("setting")
+                    # Compatible is a special case, as it's added as a meta data entry (instead of an instance).
+                    material_container = variant_dict["material_container"]
+                    compatible = container.getMetaDataEntry("compatible")
+                    if compatible is not None:
+                        builder.start("setting", {"key": "hardware compatible"})
+                        if compatible:
+                            builder.data("yes")
+                        else:
+                            builder.data("no")
+                        builder.end("setting")
 
-                for instance in variant_node.getContainer().findInstances():
-                    if container.getInstance(instance.definition.key) and container.getProperty(instance.definition.key, "value") == instance.value:
-                        # If the settings match that of the machine profile, just skip since we inherit the machine profile.
-                        continue
+                    for instance in material_container.findInstances():
+                        if container.getInstance(instance.definition.key) and container.getProperty(instance.definition.key, "value") == instance.value:
+                            # If the settings match that of the machine profile, just skip since we inherit the machine profile.
+                            continue
 
-                    self._addSettingElement(builder, instance)
+                        self._addSettingElement(builder, instance)
 
-                builder.end("hotend")
+                    if material_container.getMetaDataEntry("buildplate_compatible") and not buildplate_dict:
+                        buildplate_dict["buildplate_compatible"] = material_container.getMetaDataEntry("buildplate_compatible")
+                        buildplate_dict["buildplate_recommended"] = material_container.getMetaDataEntry("buildplate_recommended")
+                        buildplate_dict["material_container"] = material_container
+
+                    builder.end("hotend")
+
+            if buildplate_dict:
+                for variant_name in buildplate_dict["buildplate_compatible"]:
+                    builder.start("buildplate", {"id": variant_name})
+
+                    material_container = buildplate_dict["material_container"]
+                    buildplate_compatible_dict = material_container.getMetaDataEntry("buildplate_compatible")
+                    buildplate_recommended_dict = material_container.getMetaDataEntry("buildplate_recommended")
+                    if buildplate_compatible_dict:
+                        compatible = buildplate_compatible_dict[variant_name]
+                        recommended = buildplate_recommended_dict[variant_name]
+
+                        builder.start("setting", {"key": "hardware compatible"})
+                        builder.data("yes" if compatible else "no")
+                        builder.end("setting")
+
+                        builder.start("setting", {"key": "hardware recommended"})
+                        builder.data("yes" if recommended else "no")
+                        builder.end("setting")
+
+                    builder.end("buildplate")
 
             builder.end("machine")
 
@@ -842,6 +875,8 @@ class XmlMaterialProfile(InstanceContainer):
                             continue
 
                         settings = buildplate.iterfind("./um:setting", cls.__namespaces)
+                        buildplate_compatibility = True
+                        buildplate_recommended = True
                         for entry in settings:
                             key = entry.get("key")
                             if key == "hardware compatible":
@@ -849,8 +884,8 @@ class XmlMaterialProfile(InstanceContainer):
                             elif key == "hardware recommended":
                                 buildplate_recommended = cls._parseCompatibleValue(entry.text)
 
-                        buildplate_map["buildplate_compatible"][buildplate_id] = buildplate_map["buildplate_compatible"]
-                        buildplate_map["buildplate_recommended"][buildplate_id] = buildplate_map["buildplate_recommended"]
+                        buildplate_map["buildplate_compatible"][buildplate_id] = buildplate_compatibility
+                        buildplate_map["buildplate_recommended"][buildplate_id] = buildplate_recommended
 
                     for hotend in machine.iterfind("./um:hotend", cls.__namespaces):
                         hotend_name = hotend.get("id")