diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index 68635ac..855697c 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -517,6 +517,7 @@
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_IgnorePaddingSimpleL2Pooling2dUint8,
                                  ClContextControlFixture,
                                  IgnorePaddingSimpleL2Pooling2dUint8Test)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingL2Pooling2dSize3,
                                  ClContextControlFixture,
                                  IgnorePaddingL2Pooling2dSize3Test)
@@ -617,26 +618,51 @@
                                  SimpleMaxPooling3dSize2x2x2Stride1x1x1Test,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8,
+                                 ClContextControlFixture,
+                                 SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling3d,
                                  ClContextControlFixture,
                                  SimpleMaxPooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling3dUint8,
+                                 ClContextControlFixture,
+                                 SimpleMaxPooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleMaxPooling3d,
                                  ClContextControlFixture,
                                  IgnorePaddingSimpleMaxPooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleMaxPooling3dUint8,
+                                 ClContextControlFixture,
+                                 IgnorePaddingSimpleMaxPooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling3d,
                                  ClContextControlFixture,
                                  SimpleAveragePooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling3dUint8,
+                                 ClContextControlFixture,
+                                 SimpleAveragePooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LargeTensorsAveragePooling3d,
                                  ClContextControlFixture,
                                  LargeTensorsAveragePooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LargeTensorsAveragePooling3dUint8,
+                                 ClContextControlFixture,
+                                 LargeTensorsAveragePooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleAveragePooling3d,
                                  ClContextControlFixture,
                                  IgnorePaddingSimpleAveragePooling3dTest,
@@ -657,11 +683,21 @@
                                  AsymmetricNonSquareMaxPooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AsymmetricNonSquareMaxPooling3dUint8,
+                                 ClContextControlFixture,
+                                 AsymmetricNonSquareMaxPooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AsymmetricNonSquareAveragePooling3d,
                                  ClContextControlFixture,
                                  AsymmetricNonSquareAveragePooling3dTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AsymmetricNonSquareAveragePooling3dUint8,
+                                 ClContextControlFixture,
+                                 AsymmetricNonSquareAveragePooling3dUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AsymmetricNonSquareL2Pooling3d,
                                  ClContextControlFixture,
                                  AsymmetricNonSquareL2Pooling3dTest,
@@ -672,9 +708,19 @@
                                  AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTest,
                                  DataLayout::NDHWC)
 
-ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPool,
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8,
                                  ClContextControlFixture,
-                                 AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTest,
+                                 AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8Test,
+                                 DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8,
+                                 ClContextControlFixture,
+                                 AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test,
+                                 DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8,
+                                 ClContextControlFixture,
+                                 AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test,
                                  DataLayout::NDHWC)
 
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTEDAsymmetricNonSquareL2Pooling3dWithPaddingOnlyPool,
@@ -682,13 +728,20 @@
                                  AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTest,
                                  DataLayout::NDHWC)
 
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTEDAsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8,
+                                 ClContextControlFixture,
+                                 AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8Test,
+                                 DataLayout::NDHWC)
+
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling3d,
                                  ClContextControlFixture,
                                  SimpleAveragePooling3dTest,
                                  DataLayout::NDHWC)
 
-
-
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling3dUint8,
+                                 ClContextControlFixture,
+                                 SimpleAveragePooling3dUint8Test,
+                                 DataLayout::NDHWC)
 
 // Add
 ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAdd, ClContextControlFixture, AdditionTest)
diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp
index d50b253..cf541f4 100644
--- a/src/backends/neon/NeonLayerSupport.cpp
+++ b/src/backends/neon/NeonLayerSupport.cpp
@@ -58,6 +58,7 @@
 #include "workloads/NeonPadWorkload.hpp"
 #include "workloads/NeonPermuteWorkload.hpp"
 #include "workloads/NeonPooling2dWorkload.hpp"
+#include "workloads/NeonPooling3dWorkload.hpp"
 #include "workloads/NeonPreluWorkload.hpp"
 #include "workloads/NeonQLstmWorkload.hpp"
 #include "workloads/NeonQuantizeWorkload.hpp"
@@ -435,6 +436,11 @@
                                         infos[1],
                                         *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
+        case LayerType::Pooling3d:
+            return IsPooling3dSupported(infos[0],
+                                        infos[1],
+                                        *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
+                                        reasonIfUnsupported);
         case LayerType::Prelu:
             return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
         case LayerType::QLstm:
@@ -578,7 +584,7 @@
         default:
             // layers not supported in neon by default:
             // debug, fakequantization, precompiled,
-            // standin, switch, pooling3d
+            // standin, switch
             return false;
     }
 }
@@ -1213,6 +1219,14 @@
     FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling2dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
 }
 
+bool NeonLayerSupport::IsPooling3dSupported(const TensorInfo& input,
+                                            const TensorInfo& output,
+                                            const Pooling3dDescriptor& descriptor,
+                                            Optional<std::string&> reasonIfUnsupported) const
+{
+    FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling3dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+}
+
 bool NeonLayerSupport::IsPreluSupported(const armnn::TensorInfo &input,
                                         const armnn::TensorInfo &alpha,
                                         const armnn::TensorInfo &output,
diff --git a/src/backends/neon/NeonLayerSupport.hpp b/src/backends/neon/NeonLayerSupport.hpp
index b823518..783e6a0 100644
--- a/src/backends/neon/NeonLayerSupport.hpp
+++ b/src/backends/neon/NeonLayerSupport.hpp
@@ -246,7 +246,10 @@
                               const TensorInfo& output,
                               const Pooling2dDescriptor& descriptor,
                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
+    bool IsPooling3dSupported(const TensorInfo& input,
+                              const TensorInfo& output,
+                              const Pooling3dDescriptor& descriptor,
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
     bool IsPreluSupported(const TensorInfo& input,
                           const TensorInfo& alpha,
                           const TensorInfo& output,
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index f087c62..ff9ef26 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -461,6 +461,11 @@
             auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
             return std::make_unique<NeonPooling2dWorkload>(*pooling2dQueueDescriptor, info);
         }
+        case LayerType::Pooling3d :
+        {
+            auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
+            return std::make_unique<NeonPooling3dWorkload>(*pooling3dQueueDescriptor, info);
+        }
         case LayerType::PreCompiled :
         {
             auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk
index d940c92..7c0974c 100644
--- a/src/backends/neon/backend.mk
+++ b/src/backends/neon/backend.mk
@@ -67,6 +67,7 @@
         workloads/NeonPadWorkload.cpp \
         workloads/NeonPermuteWorkload.cpp \
         workloads/NeonPooling2dWorkload.cpp \
+        workloads/NeonPooling3dWorkload.cpp \
         workloads/NeonPreluWorkload.cpp \
         workloads/NeonQLstmWorkload.cpp \
         workloads/NeonQuantizedLstmWorkload.cpp \
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index b813c33..91fb4d7 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -458,7 +458,7 @@
 ARMNN_AUTO_TEST_CASE(DequantizeOffsetUint8, DequantizeOffsetUint8Test)
 ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16, DequantizeSimpleInt16Test)
 
-// Pooling
+// Pooling2d
 ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4,
                                           SimpleMaxPooling2dSize3x3Stride2x4Test, true)
 ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4Uint8,
@@ -522,6 +522,111 @@
 ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_IgnorePaddingL2Pooling2dSize3Uint8,
                                           IgnorePaddingL2Pooling2dSize3Uint8Test)
 
+//Pooling 3d
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling3dSize2x2x2Stride1x1x1,
+                              SimpleMaxPooling3dSize2x2x2Stride1x1x1Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8,
+                              SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling3d,
+                              SimpleMaxPooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling3dUint8,
+                              SimpleMaxPooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleMaxPooling3d,
+                              IgnorePaddingSimpleMaxPooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleMaxPooling3dUint8,
+                              IgnorePaddingSimpleMaxPooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling3d,
+                              SimpleAveragePooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling3dUint8,
+                              SimpleAveragePooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(LargeTensorsAveragePooling3d,
+                              LargeTensorsAveragePooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(LargeTensorsAveragePooling3dUint8,
+                              LargeTensorsAveragePooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleAveragePooling3d,
+                              IgnorePaddingSimpleAveragePooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleL2Pooling3d,
+                              SimpleL2Pooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleL2Pooling3d,
+                              IgnorePaddingSimpleL2Pooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(AsymmetricNonSquareMaxPooling3d,
+                              AsymmetricNonSquareMaxPooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(AsymmetricNonSquareMaxPooling3dUint8,
+                              AsymmetricNonSquareMaxPooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(AsymmetricNonSquareAveragePooling3d,
+                              AsymmetricNonSquareAveragePooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(AsymmetricNonSquareAveragePooling3dUint8,
+                              AsymmetricNonSquareAveragePooling3dUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(AsymmetricNonSquareL2Pooling3d,
+                              AsymmetricNonSquareL2Pooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPool,
+                              AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8,
+                              AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPool,
+                              AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8,
+                              AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTEDAsymmetricNonSquareL2Pooling3dWithPaddingOnlyPool,
+                              AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTEDAsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8,
+                              AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8Test,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling3d,
+                              SimpleAveragePooling3dTest,
+                              DataLayout::NDHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling3dUint8,
+                              SimpleAveragePooling3dUint8Test,
+                              DataLayout::NDHWC)
+
 // Activation
 ARMNN_AUTO_TEST_CASE_WITH_THF(ConstantLinearActivation, ConstantLinearActivationTest)
 
@@ -1572,6 +1677,13 @@
 ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_CompareL2Pooling2dWithReferenceUint8, ComparePooling2dUint8Test,
                                           PoolingAlgorithm::L2)
 
+ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(CompareMaxPooling3dWithRef, ComparePooling3dTest, PoolingAlgorithm::Max,
+                                          DataLayout::NDHWC)
+ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(CompareAveragePooling3dWithRef, ComparePooling3dTest,
+                                          PoolingAlgorithm::Average, DataLayout::NDHWC)
+ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(CompareL2Pooling3dWithRef, ComparePooling3dTest, PoolingAlgorithm::L2,
+                                          DataLayout::NDHWC)
+
 // Moved to NeonLayerTests_NDK_Bug.cpp
 //ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(CompareSoftmaxBeta1WithReference, CompareSoftmaxTest, 1.0f)
 //ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(CompareSoftmaxBeta2WithReference, CompareSoftmaxTest, 2.0f)
diff --git a/src/backends/neon/workloads/CMakeLists.txt b/src/backends/neon/workloads/CMakeLists.txt
index 16fae69..2209bf4 100644
--- a/src/backends/neon/workloads/CMakeLists.txt
+++ b/src/backends/neon/workloads/CMakeLists.txt
@@ -94,6 +94,8 @@
     NeonPermuteWorkload.hpp
     NeonPooling2dWorkload.cpp
     NeonPooling2dWorkload.hpp
+    NeonPooling3dWorkload.hpp
+    NeonPooling3dWorkload.cpp
     NeonPreluWorkload.cpp
     NeonPreluWorkload.hpp
     NeonQLstmWorkload.cpp
diff --git a/src/backends/neon/workloads/NeonPooling3dWorkload.cpp b/src/backends/neon/workloads/NeonPooling3dWorkload.cpp
new file mode 100644
index 0000000..4bc4f98
--- /dev/null
+++ b/src/backends/neon/workloads/NeonPooling3dWorkload.cpp
@@ -0,0 +1,64 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "NeonPooling3dWorkload.hpp"
+#include "NeonWorkloadUtils.hpp"
+#include <neon/NeonLayerSupport.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+
+namespace armnn
+{
+    using namespace armcomputetensorutils;
+    arm_compute::Status NeonPooling3dWorkloadValidate(const TensorInfo& input,
+                                                      const TensorInfo& output,
+                                                      const Pooling3dDescriptor& descriptor)
+    {
+        const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
+        const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
+        arm_compute::Pooling3dLayerInfo layerInfo = BuildArmComputePooling3dLayerInfo(descriptor);
+        return arm_compute::NEPooling3dLayer::validate(&aclInputInfo, &aclOutputInfo, layerInfo);
+    }
+
+    NeonPooling3dWorkload::NeonPooling3dWorkload( const Pooling3dQueueDescriptor& descriptor,
+                                                  const WorkloadInfo& info)
+            : NeonBaseWorkload<Pooling3dQueueDescriptor>(descriptor, info)
+    {
+        // Report Profiling Details
+        ARMNN_REPORT_PROFILING_WORKLOAD_DESC("NeonPooling3dWorkload_Construct",
+                                             descriptor.m_Parameters,
+                                             info,
+                                             this->GetGuid());
+
+        m_Data.ValidateInputsOutputs("NeonPooling3dWorkload", 1, 1);
+
+        arm_compute::ITensor& input = static_cast<IAclTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+        arm_compute::ITensor& output = static_cast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
+
+        arm_compute::DataLayout aclDataLayout = ConvertDataLayout(m_Data.m_Parameters.m_DataLayout);
+        input.info()->set_data_layout(aclDataLayout);
+        output.info()->set_data_layout(aclDataLayout);
+
+        // flag to use wider accumulators (32 bit instead of 16 for FP16) to improve accuracy
+        // enable fp_mixed_precision for the the FP16 cases that
+        // accumulation reaches a limit beyond which there is no more increment of the value
+        bool fpMixedPrecision = false;
+
+        arm_compute::Pooling3dLayerInfo layerInfo = BuildArmComputePooling3dLayerInfo(m_Data.m_Parameters,
+                                                                                      fpMixedPrecision);
+        {
+            ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "NeonPooling3dWorkload_configure");
+
+            auto layer = std::make_unique<arm_compute::NEPooling3dLayer>();
+            layer->configure(&input, &output, layerInfo);
+            m_PoolingLayer.reset(layer.release());
+        }
+    }
+    void NeonPooling3dWorkload::Execute() const
+    {
+        ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID("NeonPooling3dWorkload_Execute", this->GetGuid());
+        m_PoolingLayer->run();
+    }
+}
diff --git a/src/backends/neon/workloads/NeonPooling3dWorkload.hpp b/src/backends/neon/workloads/NeonPooling3dWorkload.hpp
new file mode 100644
index 0000000..03453f1
--- /dev/null
+++ b/src/backends/neon/workloads/NeonPooling3dWorkload.hpp
@@ -0,0 +1,33 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "NeonBaseWorkload.hpp"
+
+#include <arm_compute/runtime/NEON/functions/NEPooling3dLayer.h>
+
+namespace armnn
+{
+
+    arm_compute::Status NeonPooling3dWorkloadValidate(const TensorInfo& input,
+                                                      const TensorInfo& output,
+                                                      const Pooling3dDescriptor& descriptor);
+
+    class NeonPooling3dWorkload : public NeonBaseWorkload<Pooling3dQueueDescriptor>
+    {
+    public:
+        using BaseWorkload<Pooling3dQueueDescriptor>::m_Data;
+
+        NeonPooling3dWorkload(const Pooling3dQueueDescriptor& descriptor,
+                            const WorkloadInfo& info);
+
+        void Execute() const override;
+
+    private:
+        std::unique_ptr<arm_compute::IFunction> m_PoolingLayer;
+    };
+
+} //namespace armnn
diff --git a/src/backends/neon/workloads/NeonWorkloads.hpp b/src/backends/neon/workloads/NeonWorkloads.hpp
index d486a1d..8f83674 100644
--- a/src/backends/neon/workloads/NeonWorkloads.hpp
+++ b/src/backends/neon/workloads/NeonWorkloads.hpp
@@ -49,6 +49,7 @@
 #include "NeonPadWorkload.hpp"
 #include "NeonPermuteWorkload.hpp"
 #include "NeonPooling2dWorkload.hpp"
+#include "NeonPooling3dWorkload.hpp"
 #include "NeonPreluWorkload.hpp"
 #include "NeonQLstmWorkload.hpp"
 #include "NeonQuantizedLstmWorkload.hpp"