diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs
index 95b4cdc..501953c 100644
--- a/src/armnnSerializer/ArmnnSchema.fbs
+++ b/src/armnnSerializer/ArmnnSchema.fbs
@@ -96,7 +96,8 @@
     Constant = 12,
     SpaceToBatchNd = 13,
     BatchToSpaceNd = 14,
-    Division = 15
+    Division = 15,
+    Minimum = 16
 }
 
 // Base layer table to be used as part of other layers
@@ -172,6 +173,10 @@
     base:BindableLayerBase;
 }
 
+table MinimumLayer {
+    base:LayerBase;
+}
+
 table MultiplicationLayer {
     base:LayerBase;
 }
@@ -299,7 +304,8 @@
     ReshapeLayer,
     SoftmaxLayer,
     SpaceToBatchNdLayer,
-    DivisionLayer
+    DivisionLayer,
+    MinimumLayer
 }
 
 table AnyLayer {
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 5165d17..8b8a88d 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -260,18 +260,20 @@
     CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DepthwiseConvolution2dLayer);
 }
 
-// Build FlatBuffer for Division Layer
 void SerializerVisitor::VisitDivisionLayer(const armnn::IConnectableLayer* layer, const char* name)
 {
-    // Create FlatBuffer BaseLayer
-    auto flatBufferDivisionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Division);
+    auto fbDivisionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Division);
+    auto fbDivisionLayer     = serializer::CreateDivisionLayer(m_flatBufferBuilder, fbDivisionBaseLayer);
 
-    // Create the FlatBuffer DivisionLayer
-    auto flatBufferDivisionLayer =
-        serializer::CreateDivisionLayer(m_flatBufferBuilder, flatBufferDivisionBaseLayer);
+    CreateAnyLayer(fbDivisionLayer.o, serializer::Layer::Layer_DivisionLayer);
+}
 
-    // Add the AnyLayer to the FlatBufferLayers
-    CreateAnyLayer(flatBufferDivisionLayer.o, serializer::Layer::Layer_DivisionLayer);
+void SerializerVisitor::VisitMinimumLayer(const armnn::IConnectableLayer* layer, const char* name)
+{
+    auto fbMinimumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Minimum);
+    auto fbMinimumLayer     = serializer::CreateMinimumLayer(m_flatBufferBuilder, fbMinimumBaseLayer);
+
+    CreateAnyLayer(fbMinimumLayer.o, serializer::Layer::Layer_MinimumLayer);
 }
 
 // Build FlatBuffer for Multiplication Layer
diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp
index 6715951..ecc966c 100644
--- a/src/armnnSerializer/Serializer.hpp
+++ b/src/armnnSerializer/Serializer.hpp
@@ -82,6 +82,9 @@
                          armnn::LayerBindingId id,
                          const char* name = nullptr) override;
 
+    void VisitMinimumLayer(const armnn::IConnectableLayer* layer,
+                           const char* name = nullptr) override;
+
     void VisitMultiplicationLayer(const armnn::IConnectableLayer* layer,
                                   const char* name = nullptr) override;
 
diff --git a/src/armnnSerializer/SerializerSupport.md b/src/armnnSerializer/SerializerSupport.md
index c6d7b85..31f6310 100644
--- a/src/armnnSerializer/SerializerSupport.md
+++ b/src/armnnSerializer/SerializerSupport.md
@@ -14,6 +14,7 @@
 * DepthwiseConvolution2d
 * Division
 * FullyConnected
+* Minimum
 * Multiplication
 * Permute
 * Pooling2d
diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp
index 282b87b..4b0077c 100644
--- a/src/armnnSerializer/test/SerializerTests.cpp
+++ b/src/armnnSerializer/test/SerializerTests.cpp
@@ -255,6 +255,57 @@
                                             {commonTensorInfo.GetShape()});
 }
 
+BOOST_AUTO_TEST_CASE(SerializeMinimum)
+{
+    class VerifyMinimumName : public armnn::LayerVisitorBase<armnn::VisitorNoThrowPolicy>
+    {
+    public:
+        explicit VerifyMinimumName(const std::string& expectedMinimumLayerName)
+            : m_ExpectedMinimumLayerName(expectedMinimumLayerName) {}
+
+        void VisitMinimumLayer(const armnn::IConnectableLayer*, const char* name) override
+        {
+            BOOST_TEST(name == m_ExpectedMinimumLayerName.c_str());
+        }
+
+    private:
+        std::string m_ExpectedMinimumLayerName;
+    };
+
+    const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
+
+    const std::string minimumLayerName("minimum");
+
+    armnn::IConnectableLayer* const minimumLayer = network->AddMinimumLayer(minimumLayerName.c_str());
+    inputLayer0->GetOutputSlot(0).Connect(minimumLayer->GetInputSlot(0));
+    inputLayer1->GetOutputSlot(0).Connect(minimumLayer->GetInputSlot(1));
+
+    armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
+    minimumLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
+    inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
+    minimumLayer->GetOutputSlot(0).SetTensorInfo(info);
+
+    armnnSerializer::Serializer serializer;
+    serializer.Serialize(*network);
+
+    std::stringstream stream;
+    serializer.SaveSerializedToStream(stream);
+    BOOST_TEST(stream.str().length() > 0);
+    BOOST_TEST(stream.str().find(minimumLayerName) != stream.str().npos);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(stream.str());
+    BOOST_CHECK(deserializedNetwork);
+
+    VerifyMinimumName nameChecker(minimumLayerName);
+    deserializedNetwork->Accept(nameChecker);
+}
+
 BOOST_AUTO_TEST_CASE(SerializeMultiplication)
 {
     class VerifyMultiplicationName : public armnn::LayerVisitorBase<armnn::VisitorNoThrowPolicy>