diff --git a/src/common/transformations/include/transformations/op_conversions/fake_convert_decomposition.hpp b/src/common/transformations/include/transformations/op_conversions/fake_convert_decomposition.hpp
index 7d74fe96333bbf..e149152b2bcf6d 100644
--- a/src/common/transformations/include/transformations/op_conversions/fake_convert_decomposition.hpp
+++ b/src/common/transformations/include/transformations/op_conversions/fake_convert_decomposition.hpp
@@ -27,6 +27,6 @@ class TRANSFORMATIONS_API FakeConvertDecomposition;
 
 class ov::pass::FakeConvertDecomposition : public ov::pass::MatcherPass {
 public:
-    OPENVINO_RTTI("FakeConvertDecomposition", "0");
+    OPENVINO_MATCHER_PASS_RTTI("FakeConvertDecomposition");
     FakeConvertDecomposition();
 };
diff --git a/src/common/transformations/src/transformations/op_conversions/fake_convert_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/fake_convert_decomposition.cpp
index 3118897f8d3828..ae22970ef1546c 100644
--- a/src/common/transformations/src/transformations/op_conversions/fake_convert_decomposition.cpp
+++ b/src/common/transformations/src/transformations/op_conversions/fake_convert_decomposition.cpp
@@ -34,49 +34,37 @@ ov::pass::FakeConvertDecomposition::FakeConvertDecomposition() {
         const Output<Node> input_scale{fake_convert_node->input_value(1)};
         auto input_type = data.get_element_type();
 
-        ov::NodeVector decomp_ops;
+        ov::pass::NodeRegistry decomp_ops;
         if (input_type != input_scale.get_element_type()) {
             input_type = input_scale.get_element_type();
             data = std::make_shared<ov::op::v0::Convert>(data, input_type);
-            decomp_ops.push_back(data.get_node_shared_ptr());
+            data = decomp_ops.add(data.get_node_shared_ptr());
         }
 
         std::shared_ptr<Node> result;
-        const auto scale = std::make_shared<ov::op::v1::Multiply>(data, input_scale);
-        decomp_ops.push_back(scale);
+        const auto scale = decomp_ops.make<ov::op::v1::Multiply>(data, input_scale);
         if (fake_convert_node->get_input_size() == 2) {
-            const auto downconvert =
-                std::make_shared<ov::op::v0::Convert>(scale, fake_convert_node->get_destination_element_type());
-            decomp_ops.push_back(downconvert);
-            const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, input_type);
-            decomp_ops.push_back(upconvert);
+            const auto downconvert = decomp_ops.make<ov::op::v0::Convert>(scale, fake_convert_node->get_destination_element_type());
+            const auto upconvert = decomp_ops.make<ov::op::v0::Convert>(downconvert, input_type);
 
-            result = std::make_shared<ov::op::v1::Divide>(upconvert, input_scale);
-            decomp_ops.push_back(result);
+            result = decomp_ops.make<ov::op::v1::Divide>(upconvert, input_scale);
         } else {
             const Output<Node> input_shift{fake_convert_node->input_value(2)};
-            const auto shift = std::make_shared<ov::op::v1::Subtract>(scale, input_shift);
-            decomp_ops.push_back(shift);
+            const auto shift = decomp_ops.make<ov::op::v1::Subtract>(scale, input_shift);
 
-            const auto downconvert =
-                std::make_shared<ov::op::v0::Convert>(shift, fake_convert_node->get_destination_element_type());
-            decomp_ops.push_back(downconvert);
-            const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, input_type);
-            decomp_ops.push_back(upconvert);
+            const auto downconvert = decomp_ops.make<ov::op::v0::Convert>(shift, fake_convert_node->get_destination_element_type());
+            const auto upconvert = decomp_ops.make<ov::op::v0::Convert>(downconvert, input_type);
 
-            const auto deshift = std::make_shared<ov::op::v1::Add>(upconvert, input_shift);
-            decomp_ops.push_back(deshift);
-            result = std::make_shared<ov::op::v1::Divide>(deshift, input_scale);
-            decomp_ops.push_back(result);
+            const auto deshift = decomp_ops.make<ov::op::v1::Add>(upconvert, input_shift);
+            result = decomp_ops.make<ov::op::v1::Divide>(deshift, input_scale);
         }
 
         if (result->get_output_element_type(0) != fake_convert_node->get_output_element_type(0)) {
-            result = std::make_shared<ov::op::v0::Convert>(result, fake_convert_node->get_output_element_type(0));
-            decomp_ops.push_back(result);
+            result = decomp_ops.make<ov::op::v0::Convert>(result, fake_convert_node->get_output_element_type(0));
         }
 
         result->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info(fake_convert_node, decomp_ops);
+        ov::copy_runtime_info(fake_convert_node, decomp_ops.get());
         ov::replace_node(m.get_match_root(), result);
         return true;
     };
diff --git a/src/common/transformations/tests/op_conversions/fake_convert_decomposition_test.cpp b/src/common/transformations/tests/op_conversions/fake_convert_decomposition_test.cpp
index 948df353a2a358..f026f6cf27520b 100644
--- a/src/common/transformations/tests/op_conversions/fake_convert_decomposition_test.cpp
+++ b/src/common/transformations/tests/op_conversions/fake_convert_decomposition_test.cpp
@@ -43,70 +43,67 @@ class FakeConvertDecompositionTest : public ov::test::TestsCommon,
             result << "defaultShift=false";
         return result.str();
     }
+};
 
-protected:
-    void SetUp() override {
-        FakeConvertDecompositionParams params = this->GetParam();
+TEST_P(FakeConvertDecompositionTest, CompareFunctions) {
+    FakeConvertDecompositionParams params = this->GetParam();
 
-        Shape data_shape, scale_shape, shift_shape;
-        element::Type_t data_prec, dst_prec;
-        bool default_shift;
-        std::tie(data_shape, scale_shape, shift_shape, data_prec, dst_prec, default_shift) = params;
+    Shape data_shape, scale_shape, shift_shape;
+    element::Type_t data_prec, dst_prec;
+    bool default_shift;
+    std::tie(data_shape, scale_shape, shift_shape, data_prec, dst_prec, default_shift) = params;
 
-        std::shared_ptr<ov::Model> f(nullptr);
-        {
-            const auto data = std::make_shared<opset1::Parameter>(data_prec, PartialShape(data_shape));
-            const auto scale = std::make_shared<opset1::Constant>(data_prec, scale_shape);
-            const auto shift = std::make_shared<opset1::Constant>(data_prec, shift_shape);
+    std::shared_ptr<ov::Model> model(nullptr);
+    {
+        const auto data = std::make_shared<opset1::Parameter>(data_prec, PartialShape(data_shape));
+        const auto scale = std::make_shared<opset1::Constant>(data_prec, scale_shape);
+        const auto shift = std::make_shared<opset1::Constant>(data_prec, shift_shape);
 
-            const auto fake_convert = default_shift
-                                          ? std::make_shared<opset13::FakeConvert>(data, scale, dst_prec)
-                                          : std::make_shared<opset13::FakeConvert>(data, scale, shift, dst_prec);
-            f = std::make_shared<ov::Model>(NodeVector{fake_convert}, ParameterVector{data});
+        const auto fake_convert = default_shift
+                                        ? std::make_shared<opset13::FakeConvert>(data, scale, dst_prec)
+                                        : std::make_shared<opset13::FakeConvert>(data, scale, shift, dst_prec);
+        model = std::make_shared<ov::Model>(NodeVector{fake_convert}, ParameterVector{data});
 
-            pass::Manager manager;
-            manager.register_pass<ov::pass::InitNodeInfo>();
-            manager.register_pass<ov::pass::FakeConvertDecomposition>();
-            manager.run_passes(f);
+        pass::Manager manager;
+        manager.register_pass<ov::pass::InitNodeInfo>();
+        manager.register_pass<ov::pass::FakeConvertDecomposition>();
+        manager.run_passes(model);
 
-            OV_ASSERT_NO_THROW(check_rt_info(f));
-        }
+        OV_ASSERT_NO_THROW(check_rt_info(model));
+    }
 
-        std::shared_ptr<ov::Model> f_ref(nullptr);
-        {
-            const auto input_data = std::make_shared<opset1::Parameter>(data_prec, PartialShape(data_shape));
-            const auto input_scale = std::make_shared<opset1::Constant>(data_prec, scale_shape);
-            const auto input_shift = std::make_shared<opset1::Constant>(data_prec, shift_shape);
-            ParameterVector params;
-            params.push_back(input_data);
-            std::shared_ptr<Node> data = input_data;
-
-            std::shared_ptr<Node> result;
-            const auto scale = std::make_shared<ov::op::v1::Multiply>(data, input_scale);
-            if (default_shift) {
-                const auto downconvert = std::make_shared<ov::op::v0::Convert>(scale, dst_prec);
-                const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, data_prec);
-
-                result = std::make_shared<ov::op::v1::Divide>(upconvert, input_scale);
-            } else {
-                const auto shift = std::make_shared<ov::op::v1::Subtract>(scale, input_shift);
-
-                const auto downconvert = std::make_shared<ov::op::v0::Convert>(shift, dst_prec);
-                const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, data_prec);
-
-                const auto deshift = std::make_shared<ov::op::v1::Add>(upconvert, input_shift);
-                result = std::make_shared<ov::op::v1::Divide>(deshift, input_scale);
-            }
-
-            f_ref = std::make_shared<ov::Model>(NodeVector{result}, params);
+    std::shared_ptr<ov::Model> model_ref(nullptr);
+    {
+        const auto input_data = std::make_shared<opset1::Parameter>(data_prec, PartialShape(data_shape));
+        const auto input_scale = std::make_shared<opset1::Constant>(data_prec, scale_shape);
+        const auto input_shift = std::make_shared<opset1::Constant>(data_prec, shift_shape);
+        ParameterVector params;
+        params.push_back(input_data);
+        std::shared_ptr<Node> data = input_data;
+
+        std::shared_ptr<Node> result;
+        const auto scale = std::make_shared<ov::op::v1::Multiply>(data, input_scale);
+        if (default_shift) {
+            const auto downconvert = std::make_shared<ov::op::v0::Convert>(scale, dst_prec);
+            const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, data_prec);
+
+            result = std::make_shared<ov::op::v1::Divide>(upconvert, input_scale);
+        } else {
+            const auto shift = std::make_shared<ov::op::v1::Subtract>(scale, input_shift);
+
+            const auto downconvert = std::make_shared<ov::op::v0::Convert>(shift, dst_prec);
+            const auto upconvert = std::make_shared<ov::op::v0::Convert>(downconvert, data_prec);
+
+            const auto deshift = std::make_shared<ov::op::v1::Add>(upconvert, input_shift);
+            result = std::make_shared<ov::op::v1::Divide>(deshift, input_scale);
         }
 
-        const auto res = compare_functions(f, f_ref);
-        ASSERT_TRUE(res.first) << res.second;
+        model_ref = std::make_shared<ov::Model>(NodeVector{result}, params);
     }
-};
 
-TEST_P(FakeConvertDecompositionTest, CompareFunctions) {}
+    const auto res = compare_functions(model, model_ref);
+    ASSERT_TRUE(res.first) << res.second;
+}
 
 const std::vector<element::Type_t> data_precisions = {element::Type_t::f32,
                                                       element::Type_t::f16,