diff --git a/.clang-tidy b/.clang-tidy
index f95d01bd41..fa0f467415 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -66,6 +66,7 @@ readability-*,
 -readability-redundant-member-init,
 -readability-uppercase-literal-suffix,
 -bugprone-unchecked-optional-access,
+-cppcoreguidelines-missing-std-forward,
 '
 
 WarningsAsErrors: '*'
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
index d8c2896626..6446458982 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
@@ -556,11 +556,11 @@ template <dataset_type_tag dataset_type_> class Dataset {
     template <class type_getter, class ComponentType, typename Func,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
         requires std::invocable<Func, SpanRange<StructType>> && std::invocable<Func, RangeObject<StructType>>
-    auto for_each_component(Func&& func, Idx scenario = invalid_index) const {
+    auto for_each_component(Func func, Idx scenario = invalid_index) const {
         if (is_columnar(ComponentType::name)) {
-            return std::forward<Func>(func)(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
+            return func(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
         }
-        return std::forward<Func>(func)(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
+        return func(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
     }
 
     void set_next_cartesian_product_dimension(Dataset const* next) {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
index 297bb18bd1..8afdb97a61 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
@@ -51,18 +51,18 @@ template <class T> constexpr CType ctype_v = ctype_t<T>::value;
 // function selector based on ctype
 // the operator() of the functor should have a single template parameter
 // the selector will instantiate the operator() with relevant type
-template <class Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor&& f, Args&&... args) {
+template <class Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor f, Args&&... args) {
     using enum CType;
 
     switch (ctype) {
     case c_double:
-        return std::forward<Functor>(f).template operator()<double>(std::forward<Args>(args)...);
+        return f.template operator()<double>(std::forward<Args>(args)...);
     case c_double3:
-        return std::forward<Functor>(f).template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
+        return f.template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
     case c_int8:
-        return std::forward<Functor>(f).template operator()<int8_t>(std::forward<Args>(args)...);
+        return f.template operator()<int8_t>(std::forward<Args>(args)...);
     case c_int32:
-        return std::forward<Functor>(f).template operator()<int32_t>(std::forward<Args>(args)...);
+        return f.template operator()<int32_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CType selector", ctype};
     }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp
index 49e0a2ecd5..f4b082d91d 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp
@@ -27,31 +27,30 @@ template <typename T>
 concept calculation_type_tag = std::derived_from<T, calculation_type_t>;
 
 template <class Functor, class... Args>
-decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, Functor&& f,
-                                                  Args&&... args) {
+decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, Functor f, Args&&... args) {
     using enum CalculationSymmetry;
 
     switch (calculation_symmetry) {
     case symmetric:
-        return std::forward<Functor>(f).template operator()<symmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<symmetric_t>(std::forward<Args>(args)...);
     case asymmetric:
-        return std::forward<Functor>(f).template operator()<asymmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<asymmetric_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"Calculation symmetry selector", calculation_symmetry};
     }
 }
 
 template <class Functor, class... Args>
-decltype(auto) calculation_type_func_selector(CalculationType calculation_type, Functor&& f, Args&&... args) {
+decltype(auto) calculation_type_func_selector(CalculationType calculation_type, Functor f, Args&&... args) {
     using enum CalculationType;
 
     switch (calculation_type) {
     case CalculationType::power_flow:
-        return std::forward<Functor>(f).template operator()<power_flow_t>(std::forward<Args>(args)...);
+        return f.template operator()<power_flow_t>(std::forward<Args>(args)...);
     case CalculationType::state_estimation:
-        return std::forward<Functor>(f).template operator()<state_estimation_t>(std::forward<Args>(args)...);
+        return f.template operator()<state_estimation_t>(std::forward<Args>(args)...);
     case CalculationType::short_circuit:
-        return std::forward<Functor>(f).template operator()<short_circuit_t>(std::forward<Args>(args)...);
+        return f.template operator()<short_circuit_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CalculationType", calculation_type};
     }
@@ -59,22 +58,21 @@ decltype(auto) calculation_type_func_selector(CalculationType calculation_type,
 
 template <class Functor, class... Args>
 decltype(auto) calculation_type_symmetry_func_selector(CalculationType calculation_type,
-                                                       CalculationSymmetry calculation_symmetry, Functor&& f,
+                                                       CalculationSymmetry calculation_symmetry, Functor f,
                                                        Args&&... args) {
     calculation_type_func_selector(
         calculation_type,
         []<calculation_type_tag calculation_type, typename Functor_, typename... Args_>(
-            CalculationSymmetry calculation_symmetry_, Functor_&& f_, Args_&&... args_) {
+            CalculationSymmetry calculation_symmetry_, Functor_ f_, Args_&&... args_) {
             calculation_symmetry_func_selector(
                 calculation_symmetry_,
-                []<symmetry_tag sym, typename SubFunctor, typename... SubArgs>(SubFunctor&& sub_f,
+                []<symmetry_tag sym, typename SubFunctor, typename... SubArgs>(SubFunctor sub_f,
                                                                                SubArgs&&... sub_args) {
-                    std::forward<SubFunctor>(sub_f).template operator()<calculation_type, sym>(
-                        std::forward<SubArgs>(sub_args)...);
+                    sub_f.template operator()<calculation_type, sym>(std::forward<SubArgs>(sub_args)...);
                 },
-                std::forward<Functor_>(f_), std::forward<Args_>(args_)...);
+                f_, std::forward<Args_>(args_)...);
         },
-        calculation_symmetry, std::forward<Functor>(f), std::forward<Args>(args)...);
+        calculation_symmetry, f, std::forward<Args>(args)...);
 }
 
 template <typename T, typename sym> struct Calculator;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp
index acb1f789cb..da3c3961b4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp
@@ -36,10 +36,8 @@ class CalculationInfo : public Logger {
     void log(LogEvent tag, double value) override { log_impl(tag, value); }
     void log(LogEvent tag, Idx value) override { log_impl(tag, static_cast<double>(value)); }
     void log(std::string_view /*message*/) const { /* ignore all such events for now */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn fn) const { capturing::into_the_void(fn); }
+    template <LazyLoggingFn Fn> void log(Fn fn) const { capturing::into_the_void(fn); }
 
   private:
     Data data_;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
index cf24c55b36..d00d9035de 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
@@ -102,18 +102,14 @@ concept derives_from_any_in_list_c = (std::derived_from<T, Ts> || ...);
 
 namespace capturing {
 // perfect forward into void
-template <class... T>
-constexpr void into_the_void(T&&... /*ignored*/) { // NOLINT(cppcoreguidelines-missing-std-forward)
+template <class... T> constexpr void into_the_void(T&&... /*ignored*/) {
     // do nothing; the constexpr allows all compilers to optimize this away
 }
 } // namespace capturing
 
 // functor to include all
 struct IncludeAll {
-    template <class... T> consteval bool operator()(T&&... args) const {
-        capturing::into_the_void(std::forward<T>(args)...);
-        return true;
-    }
+    template <class... T> consteval bool operator()(T&&... /* args */) const { return true; }
 };
 constexpr IncludeAll include_all{};
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp
index 13af3df1b7..34b97a39c1 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp
@@ -20,10 +20,8 @@ class NoLogger : public Logger {
     void log(LogEvent /*tag*/, double /*value*/) override { /* no logging */ }
     void log(LogEvent /*tag*/, Idx /*value*/) override { /* no logging */ }
     void log(std::string_view /*message*/) const { /* no logging */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn fn) const { capturing::into_the_void(fn); }
+    template <LazyLoggingFn Fn> void log(Fn fn) const { capturing::into_the_void(fn); }
     template <std::derived_from<Logger> T> T& merge_into(T& destination) const { return destination; }
 };
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
index 2fc27a4e08..114e9f90df 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
@@ -39,7 +39,7 @@ namespace detail {
 template <std::ranges::viewable_range ElementGroups>
 constexpr auto sparse_encode(ElementGroups&& element_groups, Idx num_groups) {
     IdxVector result(num_groups + 1);
-    auto element_groups_view = std::views::all(std::forward<ElementGroups>(element_groups));
+    auto element_groups_view = std::views::all(element_groups);
     auto next_group = std::begin(element_groups_view);
     for (auto const group : IdxRange{num_groups}) {
         next_group = std::upper_bound(next_group, std::end(element_groups_view), group);
@@ -49,7 +49,7 @@ constexpr auto sparse_encode(ElementGroups&& element_groups, Idx num_groups) {
 }
 
 template <std::ranges::viewable_range IndPtr> constexpr auto sparse_decode(IndPtr&& indptr) {
-    auto indptr_view = std::views::all(std::forward<IndPtr>(indptr));
+    auto indptr_view = std::views::all(indptr);
     auto result = IdxVector(indptr_view.back());
     for (Idx const group : IdxRange{static_cast<Idx>(indptr_view.size()) - 1}) {
         std::fill(std::begin(result) + indptr_view[group], std::begin(result) + indptr_view[group + 1], group);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp
index e934274700..a78ff3db00 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp
@@ -35,9 +35,7 @@ class IteratorFacade {
   public:
     using iterator_category = std::random_access_iterator_tag;
 
-    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) {
-        return &(*std::forward<Self>(self));
-    }
+    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) { return &(*self); }
 
     template <typename Self, typename Other>
         requires std::same_as<std::remove_cvref_t<Self>, std::remove_cvref_t<Other>>
@@ -94,12 +92,12 @@ class IteratorFacade {
     template <typename Self, std::integral Int>
         requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
     friend constexpr std::remove_cvref_t<Self> operator+(Int offset, Self&& self) {
-        return std::forward<Self>(self) + offset;
+        return self + offset;
     }
     template <typename Self, std::integral Int>
         requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
     friend constexpr std::remove_cvref_t<Self> operator-(Self&& self, Int idx) {
-        return (std::forward<Self>(self)) + (-idx);
+        return self + (-idx);
     }
 
     template <typename Self>
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp
index 3dd8f7e49c..03b312dae3 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp
@@ -56,8 +56,8 @@ class Logger {
     virtual void log(LogEvent tag, Idx value) = 0;
 
     void log(std::string_view message) { log(LogEvent::unknown, message); }
-    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn&& fn) { log(tag, std::invoke(std::forward<Fn>(fn))); }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) { log(LogEvent::unknown, std::invoke(std::forward<Fn>(fn))); }
+    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn fn) { log(tag, std::invoke(fn)); }
+    template <LazyLoggingFn Fn> void log(Fn fn) { log(LogEvent::unknown, std::invoke(fn)); }
 
     Logger(Logger&&) noexcept = default;
     Logger& operator=(Logger&&) noexcept = default;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
index 4029c59ca4..1a16267309 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
@@ -345,8 +345,9 @@ inline void add_diag(Eigen::ArrayBase<DerivedA>& x, Eigen::ArrayBase<DerivedB> c
     x.matrix().diagonal() += y.matrix();
 }
 template <rk2_tensor DerivedA, column_vector DerivedB>
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 inline void add_diag(Eigen::ArrayBase<DerivedA>&& x, Eigen::ArrayBase<DerivedB> const& y) {
-    std::move(x).matrix().diagonal() += y.matrix();
+    x.matrix().diagonal() += y.matrix();
 }
 
 // zero tensor
@@ -418,17 +419,14 @@ template <symmetry_tag sym, class Proxy>
 inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, RealValue<symmetric_t> scalar) {
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
-            std::forward<Proxy>(current_value) = scalar * new_value;
-        } else {
-            capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
+            current_value = scalar * new_value;
         }
     } else {
         for (size_t i = 0; i != 3; ++i) {
             if (!is_nan(new_value(i))) {
-                current_value(i) = scalar * new_value(i); // can't forward due to runtime element access
+                current_value(i) = scalar * new_value(i);
             }
         }
-        capturing::into_the_void<Proxy>(std::forward<Proxy>(current_value));
     }
 }
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp
index 13fb1ed2cc..3c1853a627 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp
@@ -19,51 +19,51 @@ class JobInterface {
     template <typename Self, typename ResultDataset>
     void calculate(this Self&& self, ResultDataset const& result_data, Idx pos, Logger& logger)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
+            { self.calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).calculate_impl(result_data, pos, logger);
+        return self.calculate_impl(result_data, pos, logger);
     }
 
     template <typename Self, typename ResultDataset>
     void calculate(this Self&& self, ResultDataset const& result_data, Logger& logger) {
-        std::forward<Self>(self).calculate(result_data, Idx{}, logger);
+        self.calculate(result_data, Idx{}, logger);
     }
 
     template <typename Self>
     void cache_calculate(this Self&& self, Logger& logger)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).cache_calculate_impl(logger) } -> std::same_as<void>;
+            { self.cache_calculate_impl(logger) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).cache_calculate_impl(logger);
+        return self.cache_calculate_impl(logger);
     }
 
     template <typename Self, typename UpdateDataset>
     void prepare_job_dispatch(this Self&& self, UpdateDataset const& update_data)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
+            { self.prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).prepare_job_dispatch_impl(update_data);
+        return self.prepare_job_dispatch_impl(update_data);
     }
 
     template <typename Self, typename UpdateDataset>
     void setup(this Self&& self, UpdateDataset const& update_data, Idx scenario_idx)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
+            { self.setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).setup_impl(update_data, scenario_idx);
+        return self.setup_impl(update_data, scenario_idx);
     }
 
     template <typename Self>
     void winddown(this Self&& self)
         requires requires { // NOSONAR
-            { std::forward<Self>(self).winddown_impl() } -> std::same_as<void>;
+            { self.winddown_impl() } -> std::same_as<void>;
         }
     {
-        return std::forward<Self>(self).winddown_impl();
+        return self.winddown_impl();
     }
 
   protected:
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp
index 9076e917a0..55306d91c1 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/core_utils.hpp
@@ -16,25 +16,22 @@ namespace power_grid_model::main_core::utils {
 namespace detail {
 
 template <typename Tuple, class Functor, std::size_t... Indices>
-constexpr void run_functor_with_tuple_index_return_void(Functor&& functor, std::index_sequence<Indices...> /*unused*/) {
+constexpr void run_functor_with_tuple_index_return_void(Functor functor, std::index_sequence<Indices...> /*unused*/) {
     if constexpr (sizeof...(Indices) == 1) {
-        (std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
+        (functor.template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
     } else {
         (functor.template operator()<std::tuple_element_t<Indices, Tuple>>(), ...);
-        capturing::into_the_void(std::forward<Functor>(functor));
+        capturing::into_the_void(functor);
     }
 }
 
 template <typename Tuple, class Functor, std::size_t... Indices>
-constexpr auto run_functor_with_tuple_index_return_array(Functor&& functor,
-                                                         std::index_sequence<Indices...> /*unused*/) {
+constexpr auto run_functor_with_tuple_index_return_array(Functor functor, std::index_sequence<Indices...> /*unused*/) {
     if constexpr (sizeof...(Indices) == 1) {
-        return std::array {
-            std::forward<Functor>(functor).template operator()<std::tuple_element_t<Indices, Tuple>>()...
-        };
+        return std::array { functor.template operator()<std::tuple_element_t<Indices, Tuple>>()... };
     } else {
         auto result = std::array { functor.template operator()<std::tuple_element_t<Indices, Tuple>>()... };
-        capturing::into_the_void(std::forward<Functor>(functor));
+        capturing::into_the_void(functor);
         return result;
     }
 }
@@ -44,14 +41,14 @@ constexpr auto run_functor_with_tuple_index_return_array(Functor&& functor,
 constexpr Idx sequential{-1};
 constexpr Idx invalid_index{-1};
 
-template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor&& functor) {
-    detail::run_functor_with_tuple_index_return_void<Tuple>(std::forward<Functor>(functor),
+template <typename Tuple, class Functor> constexpr void run_functor_with_tuple_return_void(Functor functor) {
+    detail::run_functor_with_tuple_index_return_void<Tuple>(functor,
                                                             std::make_index_sequence<std::tuple_size_v<Tuple>>{});
 }
 
-template <typename Tuple, class Functor> constexpr auto run_functor_with_tuple_return_array(Functor&& functor) {
+template <typename Tuple, class Functor> constexpr auto run_functor_with_tuple_return_array(Functor functor) {
     return detail::run_functor_with_tuple_index_return_array<Tuple>(
-        std::forward<Functor>(functor), std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+        functor, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
 }
 
 } // namespace power_grid_model::main_core::utils
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp
index f64f71d775..4066b5cb3a 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp
@@ -58,7 +58,7 @@ inline void add_component(ComponentContainer& components, Inputs&& component_inp
     std::vector<Idx2D> regulated_objects;
     // loop to add component
 
-    for (auto const& input_proxy : std::views::all(std::forward<Inputs>(component_inputs))) {
+    for (auto const& input_proxy : std::views::all(component_inputs)) {
         ComponentView const input = [&input_proxy]() -> ComponentView { return input_proxy; }();
 
         ID const id = input.id;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp
index b3df895b22..44330ec876 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp
@@ -117,12 +117,11 @@ class MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     using SequenceIdxRefWrappers = std::array<std::reference_wrapper<std::vector<Idx2D> const>, n_types>;
     using ComponentFlags = std::array<bool, n_types>;
 
-    template <class Functor> static constexpr void run_functor_with_all_component_types_return_void(Functor&& functor) {
-        return utils::run_functor_with_tuple_return_void<ComponentTypesTuple>(std::forward<Functor>(functor));
+    template <class Functor> static constexpr void run_functor_with_all_component_types_return_void(Functor functor) {
+        return utils::run_functor_with_tuple_return_void<ComponentTypesTuple>(functor);
     }
-    template <class Functor>
-    static constexpr auto run_functor_with_all_component_types_return_array(Functor&& functor) {
-        return utils::run_functor_with_tuple_return_array<ComponentTypesTuple>(std::forward<Functor>(functor));
+    template <class Functor> static constexpr auto run_functor_with_all_component_types_return_array(Functor functor) {
+        return utils::run_functor_with_tuple_return_array<ComponentTypesTuple>(functor);
     }
 };
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
index 8a255b3cc4..56975fdb1d 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
@@ -125,10 +125,9 @@ template <typename Component, typename IndexType, class ComponentContainer, std:
                            std::ranges::range_reference_t<ComponentOutput>> &&
              std::convertible_to<IndexType, std::ranges::range_value_t<decltype(comp_base_sequence<Component>(
                                                 MainModelState<ComponentContainer>{}))>>
-constexpr void produce_output(MainModelState<ComponentContainer> const& state, ComponentOutput&& output,
-                              ResFunc&& func) {
+constexpr void produce_output(MainModelState<ComponentContainer> const& state, ComponentOutput&& output, ResFunc func) {
     std::ranges::transform(get_component_citer<Component>(state.components), comp_base_sequence<Component>(state),
-                           std::ranges::begin(std::forward<ComponentOutput>(output)), std::forward<ResFunc>(func));
+                           std::ranges::begin(output), func);
 }
 
 } // namespace detail
@@ -508,10 +507,9 @@ template <std::derived_from<Base> Component, class ComponentContainer, solver_ou
              }
 constexpr void output_result(MainModelState<ComponentContainer> const& state,
                              MathOutput<std::vector<SolverOutputType>> const& math_output, ComponentOutput&& output) {
-    detail::produce_output<Component, Idx2D>(
-        state, std::forward<ComponentOutput>(output), [&math_output](Component const& component, Idx2D math_id) {
-            return output_result<Component>(component, math_output.solver_output, math_id);
-        });
+    detail::produce_output<Component, Idx2D>(state, output, [&math_output](Component const& component, Idx2D math_id) {
+        return output_result<Component>(component, math_output.solver_output, math_id);
+    });
 }
 template <std::derived_from<Base> Component, class ComponentContainer, solver_output_type SolverOutputType,
           std::ranges::viewable_range ComponentOutput>
@@ -524,11 +522,10 @@ template <std::derived_from<Base> Component, class ComponentContainer, solver_ou
              }
 constexpr void output_result(MainModelState<ComponentContainer> const& state,
                              MathOutput<std::vector<SolverOutputType>> const& math_output, ComponentOutput&& output) {
-    detail::produce_output<Component, Idx2D>(state, std::forward<ComponentOutput>(output),
-                                             [&state, &math_output](Component const& component, Idx2D const math_id) {
-                                                 return output_result<Component>(component, state,
-                                                                                 math_output.solver_output, math_id);
-                                             });
+    detail::produce_output<Component, Idx2D>(
+        state, output, [&state, &math_output](Component const& component, Idx2D const math_id) {
+            return output_result<Component>(component, state, math_output.solver_output, math_id);
+        });
 }
 template <std::derived_from<Base> Component, class ComponentContainer, solver_output_type SolverOutputType,
           std::ranges::viewable_range ComponentOutput>
@@ -541,11 +538,10 @@ template <std::derived_from<Base> Component, class ComponentContainer, solver_ou
              }
 constexpr void output_result(MainModelState<ComponentContainer> const& state,
                              MathOutput<std::vector<SolverOutputType>> const& math_output, ComponentOutput&& output) {
-    detail::produce_output<Component, Idx>(state, std::forward<ComponentOutput>(output),
-                                           [&state, &math_output](Component const& component, Idx const obj_seq) {
-                                               return output_result<Component, ComponentContainer>(
-                                                   component, state, math_output.solver_output, obj_seq);
-                                           });
+    detail::produce_output<Component, Idx>(
+        state, output, [&state, &math_output](Component const& component, Idx const obj_seq) {
+            return output_result<Component, ComponentContainer>(component, state, math_output.solver_output, obj_seq);
+        });
 }
 template <std::derived_from<Base> Component, class ComponentContainer, solver_output_type SolverOutputType,
           std::ranges::viewable_range ComponentOutput>
@@ -559,8 +555,7 @@ template <std::derived_from<Base> Component, class ComponentContainer, solver_ou
 constexpr void output_result(MainModelState<ComponentContainer> const& state,
                              MathOutput<std::vector<SolverOutputType>> const& math_output, ComponentOutput&& output) {
     detail::produce_output<Component, Idx2DBranch3>(
-        state, std::forward<ComponentOutput>(output),
-        [&math_output](Component const& component, Idx2DBranch3 const& math_id) {
+        state, output, [&math_output](Component const& component, Idx2DBranch3 const& math_id) {
             return output_result<Component>(component, math_output.solver_output, math_id);
         });
 }
@@ -575,10 +570,9 @@ template <std::derived_from<Base> Component, class ComponentContainer, typename
              }
 constexpr void output_result(MainModelState<ComponentContainer> const& state,
                              MathOutput<SolverOutputType> const& math_output, ComponentOutput&& output) {
-    detail::produce_output<Component, Idx>(state, std::forward<ComponentOutput>(output),
-                                           [&state, &math_output](Component const& component, Idx const obj_seq) {
-                                               return output_result<Component, ComponentContainer>(
-                                                   component, state, math_output, obj_seq);
-                                           });
+    detail::produce_output<Component, Idx>(
+        state, output, [&state, &math_output](Component const& component, Idx const obj_seq) {
+            return output_result<Component, ComponentContainer>(component, state, math_output, obj_seq);
+        });
 }
 } // namespace power_grid_model::main_core
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index 013e0e9abd..637f52b272 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -35,12 +35,12 @@ template <typename Component, class ComponentContainer, typename ResType, typena
     requires common::component_container_c<ComponentContainer, Component> &&
              std::invocable<std::remove_cvref_t<ResFunc>, Component const&> &&
              std::convertible_to<std::invoke_result_t<ResFunc, Component const&>, ResType>
-constexpr void apply_registration(ComponentContainer const& components, std::vector<ResType>& target, ResFunc&& func) {
+constexpr void apply_registration(ComponentContainer const& components, std::vector<ResType>& target, ResFunc func) {
     auto const begin = components.template citer<Component>().begin();
     auto const end = components.template citer<Component>().end();
 
     target.resize(std::distance(begin, end));
-    std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
+    std::transform(begin, end, target.begin(), func);
 }
 
 template <std::same_as<Node> Component, class ComponentContainer>
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
index 10ace12e85..6e23d5a293 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
@@ -191,13 +191,13 @@ inline void get_component_sequence_impl(ComponentContainer const& components, El
     using UpdateType = typename Component::UpdateType;
 
     if (n_comp_elements < 0) {
-        std::ranges::transform(std::forward<Elements>(elements), destination, [&components](UpdateType const& update) {
+        std::ranges::transform(elements, destination, [&components](UpdateType const& update) {
             return get_component_idx_by_id<Component>(components, update.id);
         });
     } else {
         assert(std::ranges::ssize(elements) <= n_comp_elements);
         std::ranges::transform(
-            std::forward<Elements>(elements), destination,
+            elements, destination,
             [group = get_component_group_idx<Component>(components), index = 0](auto const& /*update*/) mutable {
                 return Idx2D{group, index++}; // NOSONAR
             });
@@ -210,8 +210,7 @@ inline std::vector<Idx2D> get_component_sequence_by_iter(ComponentContainer cons
                                                          Idx n_comp_elements = na_Idx) {
     std::vector<Idx2D> result;
     result.reserve(std::ranges::size(elements));
-    get_component_sequence_impl<Component>(components, std::forward<Elements>(elements), std::back_inserter(result),
-                                           n_comp_elements);
+    get_component_sequence_impl<Component>(components, elements, std::back_inserter(result), n_comp_elements);
     return result;
 }
 
@@ -280,7 +279,7 @@ inline UpdateChange update_component(ComponentContainer& components, Updates&& c
                 *changed_it++ = sequence_single;
             }
         },
-        std::views::all(std::forward<Updates>(component_updates)), sequence_idx);
+        std::views::all(component_updates), sequence_idx);
 
     return state_changed;
 }
@@ -290,7 +289,7 @@ template <component_c Component, class ComponentContainer, std::ranges::viewable
 inline UpdateChange update_component(ComponentContainer& components, ComponentUpdates&& component_updates,
                                      OutputIterator changed_it) {
     return update_component<Component>(
-        components, std::forward<ComponentUpdates>(component_updates), changed_it,
+        components, component_updates, changed_it,
         detail::get_component_sequence_by_iter<Component>(components, component_updates));
 }
 
@@ -310,15 +309,14 @@ inline void update_inverse(ComponentContainer const& components, Updates&& updat
             auto const& comp = get_component<Component>(components, sequence_single);
             *destination++ = comp.inverse(update_data);
         },
-        std::forward<Updates>(updates), sequence_idx);
+        updates, sequence_idx);
 }
 template <component_c Component, class ComponentContainer, std::ranges::viewable_range Updates,
           std::output_iterator<typename Component::UpdateType> OutputIterator>
     requires common::component_container_c<ComponentContainer, Component>
 inline void update_inverse(ComponentContainer const& components, Updates&& updates, OutputIterator destination) {
-    return update_inverse<Component>(
-        components, updates, destination,
-        detail::get_component_sequence_by_iter<Component>(components, std::forward<Updates>(updates)));
+    return update_inverse<Component>(components, updates, destination,
+                                     detail::get_component_sequence_by_iter<Component>(components, updates));
 }
 
 } // namespace power_grid_model::main_core::update
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
index d0cff2b9d8..8f46bb286a 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
@@ -118,7 +118,7 @@ class MainModelImpl {
     template <std::derived_from<Base> CompType, std::ranges::viewable_range Inputs>
     void add_component(Inputs&& components) {
         assert(!construction_complete_);
-        main_core::add_component<CompType>(state_.components, std::forward<Inputs>(components), system_frequency_);
+        main_core::add_component<CompType>(state_.components, components, system_frequency_);
     }
 
     void add_components(ConstDataset const& input_data, Idx pos = 0) {
@@ -150,7 +150,7 @@ class MainModelImpl {
         }
 
         UpdateChange const changed = main_core::update::update_component<CompType>(
-            state_.components, std::forward<Updates>(updates),
+            state_.components, updates,
             std::back_inserter(std::get<comp_index>(solvers_cache_status_.changed_components_indices())), sequence_idx);
 
         // update, get changed variable
@@ -284,14 +284,14 @@ class MainModelImpl {
                  solver_output_type<std::invoke_result_t<
                      SolveFn, MathSolverType&, YBus const&,
                      typename std::invoke_result_t<PrepareInputFn, Idx /*n_math_solvers*/>::const_reference>>
-    auto calculate_(PrepareInputFn&& prepare_input, SolveFn&& solve, Logger& logger) {
+    auto calculate_(PrepareInputFn prepare_input, SolveFn solve, Logger& logger) {
         using InputType = typename std::invoke_result_t<PrepareInputFn, Idx /*n_math_solvers*/>::const_reference;
         using SolverOutputType = typename std::invoke_result_t<SolveFn, MathSolverType&, YBus const&, InputType>;
         using sym = typename SolverOutputType::sym;
 
         assert(construction_complete_);
         // prepare
-        auto const& input = [this, &logger, prepare_input_ = std::forward<PrepareInputFn>(prepare_input)] {
+        auto const& input = [this, &logger, prepare_input_ = prepare_input] {
             Timer const timer{logger, LogEvent::prepare};
             assert(construction_complete_);
             prepare_solvers<sym>(state_, solver_preparation_context_, solvers_cache_status_);
@@ -300,7 +300,7 @@ class MainModelImpl {
             return prepare_input_(get_n_math_solvers<ModelType>(state_));
         }();
         // calculate
-        return [this, &logger, &input, solve_ = std::forward<SolveFn>(solve)] {
+        return [this, &logger, &input, solve_ = solve] {
             Timer const timer{logger, LogEvent::math_calculation};
             auto& solvers = main_core::get_solvers<sym>(solver_preparation_context_.math_state);
             auto& y_bus_vec = main_core::get_y_bus<sym>(solver_preparation_context_.math_state);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
index 8985383a5a..f871c64a6b 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
@@ -409,7 +409,7 @@ template <symmetry_tag sym> class YBus {
             parameters_changed(true);
         }
 
-        for (auto const entry : std::forward<Entries>(y_bus_entries)) {
+        for (auto const entry : y_bus_entries) {
             // start admittance accumulation with zero
             ComplexTensor<sym> entry_admittance{0.0};
             // loop over all entries of this position
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
index b6b73f1966..5e700e2b13 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
@@ -274,9 +274,9 @@ inline auto retrieve_regulator_info(State const& state) -> RegulatedObjects {
     return regulated_objects;
 }
 
-template <typename F> inline void for_all_vertices(TransformerGraph const& graph, F&& func) {
+template <typename F> inline void for_all_vertices(TransformerGraph const& graph, F func) {
     BGL_FORALL_VERTICES(v, graph, TransformerGraph) { func(v); }
-    capturing::into_the_void(std::forward<F>(func));
+    capturing::into_the_void(func);
 }
 
 template <main_core::main_model_state_c State>
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
index 71e109126a..768c1fc1e4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
@@ -189,9 +189,9 @@ class Topology {
         comp_coup_.voltage_regulator.resize(comp_topo_.regulated_object_idx.size(), unknown_idx2d);
     }
 
-    template <typename F> static void for_all_vertices(GlobalGraph const& graph, F&& func) {
+    template <typename F> static void for_all_vertices(GlobalGraph const& graph, F func) {
         BGL_FORALL_VERTICES(v, graph, GlobalGraph) { func(v); }
-        capturing::into_the_void(std::forward<F>(func));
+        capturing::into_the_void(func);
     }
 
     void build_sparse_graph() {
diff --git a/power_grid_model_c/power_grid_model_c/src/model.cpp b/power_grid_model_c/power_grid_model_c/src/model.cpp
index df7176c7c6..ea65384d70 100644
--- a/power_grid_model_c/power_grid_model_c/src/model.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/model.cpp
@@ -201,7 +201,7 @@ constexpr BatchExceptionHandler batch_exception_handler{};
 template <typename T, std::ranges::input_range R>
     requires std::convertible_to<std::ranges::range_value_t<R>, T>
 void append_range(std::vector<T>& vec, R&& range) {
-    std::ranges::move(std::forward<R>(range), std::back_inserter(vec));
+    std::ranges::move(range, std::back_inserter(vec));
 }
 
 class MDBatchExceptionHandler : public power_grid_model_c::DefaultExceptionHandler {
diff --git a/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/handle.hpp b/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/handle.hpp
index 5433387b09..57756e00c8 100644
--- a/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/handle.hpp
+++ b/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/handle.hpp
@@ -92,12 +92,12 @@ class Handle {
         }
     }
 
-    template <typename Func, typename... Args> auto call_with(Func&& func, Args&&... args) const {
-        if constexpr (std::is_void_v<decltype(std::forward<Func>(func)(get(), std::forward<Args>(args)...))>) {
-            std::forward<Func>(func)(get(), std::forward<Args>(args)...);
+    template <typename Func, typename... Args> auto call_with(Func func, Args&&... args) const {
+        if constexpr (std::is_void_v<decltype(func(get(), std::forward<Args>(args)...))>) {
+            func(get(), std::forward<Args>(args)...);
             check_error();
         } else {
-            auto result = std::forward<Func>(func)(get(), std::forward<Args>(args)...);
+            auto result = func(get(), std::forward<Args>(args)...);
             check_error();
             return result;
         }
diff --git a/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/utils.hpp b/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/utils.hpp
index 5166f2003c..11081efeec 100644
--- a/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/utils.hpp
+++ b/power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/utils.hpp
@@ -55,25 +55,24 @@ class UnsupportedPGM_CType : public PowerGridError {
 };
 
 template <class Functor, class... Args>
-decltype(auto) pgm_type_func_selector(enum PGM_CType type, Functor&& f, Args&&... args) {
+decltype(auto) pgm_type_func_selector(enum PGM_CType type, Functor f, Args&&... args) {
     switch (type) {
     case PGM_int32:
-        return std::forward<Functor>(f).template operator()<ID>(std::forward<Args>(args)...);
+        return f.template operator()<ID>(std::forward<Args>(args)...);
     case PGM_int8:
-        return std::forward<Functor>(f).template operator()<IntS>(std::forward<Args>(args)...);
+        return f.template operator()<IntS>(std::forward<Args>(args)...);
     case PGM_double:
-        return std::forward<Functor>(f).template operator()<double>(std::forward<Args>(args)...);
+        return f.template operator()<double>(std::forward<Args>(args)...);
     case PGM_double3:
-        return std::forward<Functor>(f).template operator()<std::array<double, 3>>(std::forward<Args>(args)...);
+        return f.template operator()<std::array<double, 3>>(std::forward<Args>(args)...);
     default:
         throw UnsupportedPGM_CType();
     }
 }
 
 template <class Functor, class... Args>
-decltype(auto) pgm_type_func_selector(MetaAttribute const* attribute, Functor&& f, Args&&... args) {
-    return pgm_type_func_selector(MetaData::attribute_ctype(attribute), std::forward<Functor>(f),
-                                  std::forward<Args>(args)...);
+decltype(auto) pgm_type_func_selector(MetaAttribute const* attribute, Functor f, Args&&... args) {
+    return pgm_type_func_selector(MetaData::attribute_ctype(attribute), f, std::forward<Args>(args)...);
 }
 
 } // namespace power_grid_model_cpp
diff --git a/tests/cpp_unit_tests/test_calculation_info.cpp b/tests/cpp_unit_tests/test_calculation_info.cpp
index d9a426c6eb..e1ef875013 100644
--- a/tests/cpp_unit_tests/test_calculation_info.cpp
+++ b/tests/cpp_unit_tests/test_calculation_info.cpp
@@ -58,13 +58,13 @@ void report_checker_helper(auto& report, Idx n_threads = Idx{1}) {
 
 template <typename JobFn>
     requires std::invocable<JobFn, Idx>
-void run_parallel_jobs(Idx n_threads, JobFn&& job) {
+void run_parallel_jobs(Idx n_threads, JobFn job) {
     std::vector<std::jthread> threads;
     threads.reserve(n_threads);
     for ([[maybe_unused]] Idx const i : IdxRange{n_threads}) {
         threads.emplace_back(job, n_threads);
     }
-    capturing::into_the_void(std::forward<JobFn>(job));
+    capturing::into_the_void(job);
 }
 } // namespace
 
diff --git a/tests/cpp_unit_tests/test_text_logger.cpp b/tests/cpp_unit_tests/test_text_logger.cpp
index d58cfeeefa..e018ba2c05 100644
--- a/tests/cpp_unit_tests/test_text_logger.cpp
+++ b/tests/cpp_unit_tests/test_text_logger.cpp
@@ -77,13 +77,12 @@ void multi_threaded_report_checker_helper(Idx n_threads, std::string_view report
 
 template <typename JobFn>
     requires std::invocable<JobFn, Idx, MultiThreadedTextLogger&>
-void run_parallel_jobs(Idx n_threads, MultiThreadedTextLogger& logger, JobFn&& job) {
+void run_parallel_jobs(Idx n_threads, MultiThreadedTextLogger& logger, JobFn job) {
     std::vector<std::jthread> threads;
     threads.reserve(n_threads);
     for (Idx const idx : IdxRange{n_threads}) {
         threads.emplace_back(job, idx, std::ref(logger));
     }
-    capturing::into_the_void(std::forward<JobFn>(job));
 }
 } // namespace
 
diff --git a/tests/cpp_validation_tests/test_validation.cpp b/tests/cpp_validation_tests/test_validation.cpp
index d1b5d5c24a..58df7ad547 100644
--- a/tests/cpp_validation_tests/test_validation.cpp
+++ b/tests/cpp_validation_tests/test_validation.cpp
@@ -92,8 +92,8 @@ class Subcase {
     // The structure of this function is similar to how pytest.raises and pytest.mark.xfail work.
     template <typename T>
         requires std::invocable<std::remove_cvref_t<T>, Subcase&>
-    void execute_case(T&& statement) noexcept {
-        CHECK_NOTHROW(maybe_mark_xfail(maybe_with_raises(std::forward<T>(statement)))(*this));
+    void execute_case(T statement) noexcept {
+        CHECK_NOTHROW(maybe_mark_xfail(maybe_with_raises(statement))(*this));
     }
 
   private:
@@ -103,8 +103,8 @@ class Subcase {
 
     template <typename T>
         requires std::invocable<std::remove_cvref_t<T>, Subcase&>
-    auto maybe_with_raises(T&& statement) noexcept {
-        return [this, statement_ = std::forward<T>(statement)](Subcase& subcase) {
+    auto maybe_with_raises(T statement) noexcept {
+        return [this, statement_ = std::move(statement)](Subcase& subcase) {
             if (!raises_) {
                 return statement_(subcase);
             }
@@ -125,8 +125,8 @@ class Subcase {
 
     template <typename T>
         requires std::invocable<std::remove_cvref_t<T>, Subcase&>
-    auto maybe_mark_xfail(T&& statement) noexcept {
-        return [this, statement_ = std::forward<T>(statement)](Subcase& subcase) {
+    auto maybe_mark_xfail(T statement) noexcept {
+        return [this, statement_ = std::move(statement)](Subcase& subcase) {
             if (!xfail_raises_) {
                 return statement_(subcase);
             }
@@ -592,7 +592,7 @@ constexpr bool should_skip_test(CaseParam const& /*param*/) { return false; }
 
 template <typename T>
     requires std::invocable<std::remove_cvref_t<T>, Subcase&>
-void execute_test(CaseParam const& param, T&& func) noexcept {
+void execute_test(CaseParam const& param, T func) noexcept {
     Subcase subcase{param.raises, param.xfail};
     bool const skip = should_skip_test(param);
     std::cout << std::format("Validation test: {}{}{}\n", param.case_name, skip ? " [skipped]" : "",
@@ -601,7 +601,7 @@ void execute_test(CaseParam const& param, T&& func) noexcept {
         return;
     }
 
-    subcase.execute_case(std::forward<T>(func));
+    subcase.execute_case(func);
 }
 
 void validate_single_case(CaseParam const& param) {
diff --git a/tests/native_api_tests/test_api_model.cpp b/tests/native_api_tests/test_api_model.cpp
index 178ce425aa..1a1399a802 100644
--- a/tests/native_api_tests/test_api_model.cpp
+++ b/tests/native_api_tests/test_api_model.cpp
@@ -96,10 +96,10 @@ void check_exception(PowerGridError const& e, PGM_ErrorCode const& reference_err
 }
 
 template <typename Func, class... Args>
-void check_throws_with(Func&& func, PGM_ErrorCode const& reference_error, std::string_view reference_err_msg,
+void check_throws_with(Func func, PGM_ErrorCode const& reference_error, std::string_view reference_err_msg,
                        Args&&... args) {
     try {
-        std::forward<Func>(func)(std::forward<Args>(args)...);
+        func(std::forward<Args>(args)...);
         FAIL("Expected error not thrown.");
     } catch (PowerGridError const& e) {
         check_exception(e, reference_error, reference_err_msg);