diff --git a/mesh_handle/README.md b/mesh_handle/README.md
index 20f220981d..8be544983a 100644
--- a/mesh_handle/README.md
+++ b/mesh_handle/README.md
@@ -12,5 +12,6 @@ The folder's most important files are:
 - The [element.hxx](element.hxx) defines the elements (mesh or ghost elements) of the mesh handle.
 - The [competences.hxx](competences.hxx) defines additional competences/functionality of an element to access additional data.
 - The [competence_pack.hxx](competence_pack.hxx) is needed to pack element or mesh competences to pass it as template parameter to the mesh.
+- The [data_handler.hxx](data_handler.hxx) provides competences to work with element data.
 
 Headers in the [internal/](internal/) folder are only intended to implement details of the mesh handle, so they should not need to be included for any other purpose.
\ No newline at end of file
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index d7406b5112..34f030d8b3 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -3,7 +3,7 @@
   t8code is a C library to manage a collection (a forest) of multiple
   connected adaptive space-trees of general element classes in parallel.
 
-  Copyright (C) 2025 the developers
+  Copyright (C) 2026 the developers
 
   t8code is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -21,44 +21,88 @@
 */
 
 /** \file competence_pack.hxx
- * Define to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * Define classes to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * We have one class for element competences and one for mesh competences.
+ * There are several predefined competence packs for different use cases, e.g. for all caching competences or
+ * all data related competences.
+ * Use the union operator to combine different competence packs.
  */
 
 #pragma once
 
 #include "competences.hxx"
+#include "data_handler.hxx"
 #include "internal/competence_pack_union.hxx"
 namespace t8_mesh_handle
 {
-/** Class to pack different competences into one template parameter for the \ref mesh class.
- * \tparam TCompetence The competences to be packed.
+// --- Element competence pack. ---
+/** Class to pack different element competences into one template parameter for the \ref mesh class.
+ * \tparam TElementCompetence The competences to be packed.
  */
-template <template <typename> class... TCompetence>
-struct competence_pack
+template <template <typename> class... TElementCompetence>
+struct element_competence_pack
 {
   /** Apply the competence pack to a template class, e.g. the \ref element class.
-   * \tparam Target The target template class to apply the \a TCompetence pack to.
+   * \tparam TMeshClass The mesh class given to the element class.
+   * \tparam Target The target template class to apply the \a TElementCompetence pack to.
    */
-  template <typename mesh_class, template <typename, template <typename> class...> class Target>
-  using apply = Target<mesh_class, TCompetence...>;
+  template <typename TMeshClass, template <typename, template <typename> class...> class Target>
+  using apply = Target<TMeshClass, TElementCompetence...>;
 
-  using is_competence_pack = void; /**< Tag to identify this class. */
+  using is_element_competence_pack = void; /**< Tag to identify this class. */
 };
 
-/** Predefined competence pack combining all caching competences. */
-using all_cache_competences
-  = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid, cache_face_areas,
-                    cache_face_centroids, cache_face_normals, cache_neighbors>;
+/** Empty competence pack. */
+using empty_element_competences = element_competence_pack<>;
 
-/** Predefined competence pack combining all competences related to faces. */
-using cache_face_competences
-  = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
+/** Predefined element competence pack combining all caching competences. */
+using all_cache_element_competences
+  = element_competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid, cache_face_areas,
+                            cache_face_centroids, cache_face_normals, cache_neighbors>;
 
-/** Compute the unique union of the competences of several \ref t8_mesh_handle::competence_pack 's.
- *  This produces a new \ref t8_mesh_handle::competence_pack containing all competences of the competence packs 
- *  with duplicates removed.
- * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
- *         Each competence pack is expected to be of type \ref t8_mesh_handle::competence_pack.
+/** Predefined element competence pack combining all competences related to faces. */
+using cache_face_element_competences
+  = element_competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
+
+/** Predefined element competence pack combining all competences related to data. 
+ *  Please note that you must combine this with \ref t8_mesh_handle::data_mesh_competences. */
+using data_element_competences = element_competence_pack<element_data_element_competence>;
+
+// --- Mesh competence pack. ---
+/** Class to pack different mesh competences into one template parameter for the \ref mesh class.
+ * \tparam TMeshCompetence The mesh competences to be packed.
+ */
+template <template <typename> class... TMeshCompetence>
+struct mesh_competence_pack
+{
+  /** Apply the mesh competence pack to a mesh type.
+   *  By inheriting from all mesh competences, the functionality of the competences gets added to the mesh type.
+   *  \tparam TMesh The mesh type to which the competences are applied.
+   */
+  template <typename TMesh>
+  struct apply: public TMeshCompetence<TMesh>...
+  {
+  };
+
+  using is_mesh_competence_pack = void; /**< Tag to identify this class. */
+};
+
+/** Empty competence pack. */
+using empty_mesh_competences = mesh_competence_pack<>;
+
+/** Predefined mesh competence pack combining all competences related to data. 
+ * If you want to access the data also via the elements, combine this with \ref t8_mesh_handle::data_element_competences.
+ */
+template <T8MPISafeType TElementDataType>
+using data_mesh_competences = mesh_competence_pack<element_data_mesh_competence<TElementDataType>::template type>;
+
+// --- Compute union of competence packs. ---
+/** Compute the unique union of the competences of several competence_pack. This could be
+ * \ref t8_mesh_handle::element_competence_pack or \ref t8_mesh_handle::mesh_competence_pack.
+ *  A new competence pack is produced containing all competences of the given competence packs with duplicates removed.
+ * \tparam TPacks The competence packs for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of the same type and of type 
+ *         \ref t8_mesh_handle::element_competence_pack or \ref t8_mesh_handle::mesh_competence_pack.
  */
 template <typename... TPacks>
 using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
new file mode 100644
index 0000000000..e8e18ef54a
--- /dev/null
+++ b/mesh_handle/data_handler.hxx
@@ -0,0 +1,171 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2026 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file data_handler.hxx
+ * Handler for the element data of a \ref t8_mesh_handle::mesh.
+ * The file defines a mesh and an element competence for element data handling.
+ * Use both competences together if you want to manage element data for the elements of the mesh and access it directly for each element.
+ */
+#pragma once
+
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_types/t8_crtp.hxx>
+#include <type_traits>
+#include <vector>
+
+namespace t8_mesh_handle
+{
+// --- Mesh competence for element data management. ---
+/** Concept to ensure that a type is MPI safe. */
+template <typename TType>
+concept T8MPISafeType
+  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
+
+/** Handler for the element data of a \ref mesh.
+ * Use this competence if you want to manage element data for the elements of the mesh.
+ * Use the helper \ref element_data_mesh_competence to get this competence with the correct template parameters form for the mesh. 
+ * If you want to access the data not only in vector form but also directly for each element, 
+ * you can combine this competence with the \ref element_data_element_competence competence.
+ * In summary you can use the competences like this: 
+ *    mesh<element_competence_pack<element_data_element_competence>,
+ *         mesh_competence_pack<element_data_mesh_competence<YourElementDataType>::template type>>;
+ * Some predefined competences are also defined in \ref competence_pack.hxx.
+ *
+ * \tparam TUnderlying Use the \ref mesh class here.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
+template <typename TUnderlying, T8MPISafeType TElementDataType>
+class element_data_mesh_competence_impl: public t8_crtp_basic<TUnderlying> {
+ public:
+  using ElementDataType = TElementDataType; /**< Make Type of the element data publicly accessible. */
+
+  /** Set the element data vector. The vector should have the length of num_local_elements.
+   * \param [in] element_data The element data vector to set with one entry of class TElementDataType 
+   *            for each local mesh element (excluding ghosts).
+   */
+  void
+  set_element_data (std::vector<TElementDataType> element_data)
+  {
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    T8_ASSERT (element_data.size () == static_cast<size_t> (num_local_elements));
+    m_element_data.reserve (num_local_elements + num_ghosts);
+    m_element_data = std::move (element_data);
+  }
+
+  /** Get the element data vector.
+   * The element data of the local mesh elements can be set using \ref set_element_data.
+   * If ghost entries should be filled, one should call \ref exchange_ghost_data on each process first.
+   * \return Element data vector with data of Type TElementDataType.
+   */
+  const std::vector<TElementDataType>&
+  get_element_data () const
+  {
+    return m_element_data;
+  }
+
+  /** Exchange the element data for ghost elements between processes.
+  * This routine has to be called on each process after setting the element data for all local elements.
+  */
+  void
+  exchange_ghost_data ()
+  {
+    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
+    sc_array* sc_array_wrapper;
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    m_element_data.resize (num_local_elements + num_ghosts);
+    sc_array_wrapper
+      = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType), num_local_elements + num_ghosts);
+
+    // Data exchange: entries with indices > num_local_elements will get overwritten.
+    t8_forest_ghost_exchange_data (this->underlying ().get_forest (), sc_array_wrapper);
+
+    sc_array_destroy (sc_array_wrapper);
+  }
+
+ protected:
+  std::vector<TElementDataType> m_element_data; /**< Vector storing the (local) element data. */
+};
+
+/** Wrapper for \ref element_data_mesh_competence_impl to hide TUnderlying and provide the form needed to 
+ * pass it as a mesh competence.
+ * Use mesh_competence_pack<element_data_mesh_competence<YourElementDataType>::template type> 
+ * to get this competence with the correct template parameter form for the mesh.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
+template <T8MPISafeType TElementDataType>
+struct element_data_mesh_competence
+{
+  /** Type to provide the form needed for the mesh competence pack. 
+  * \tparam TUnderlying Use the \ref mesh class here.
+  */
+  template <typename TUnderlying>
+  using type = element_data_mesh_competence_impl<TUnderlying, TElementDataType>;
+};
+
+// --- Element competence for element data management. ---
+/** Element competence to enable that element data can be accessed directly for each element of the mesh.
+ * \note This competence requires that the mesh has the \ref element_data_mesh_competence_impl 
+ *     (or \ref element_data_mesh_competence) competence that defines the element data vector and the element data type.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct element_data_element_competence: public t8_crtp_basic<TUnderlying>
+{
+ public:
+  // --- Getter and setter for element data. ---
+  /** Set the element data for the element. 
+   * \note You can only set element data for non-ghost elements.
+   * \param [in] element_data The element data to be set of Type TMeshClass::ElementDataType.
+   */
+  void
+  set_element_data (auto element_data)
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    SC_CHECK_ABORT (!this->underlying ().is_ghost_element (), "Element data cannot be set for ghost elements.\n");
+    this->underlying ().m_mesh->m_element_data.reserve (this->underlying ().m_mesh->get_num_local_elements ()
+                                                        + this->underlying ().m_mesh->get_num_ghosts ());
+    this->underlying ().m_mesh->m_element_data[this->underlying ().get_element_handle_id ()] = std::move (element_data);
+  }
+
+  /** Getter for the element data.
+   * For ghost elements ensure that \ref element_data_mesh_competence_impl::exchange_ghost_data is called on 
+   * each process first.
+   * Element data for non-ghost elements can be accessed (if set) directly.
+   * \return Element data with data of Type TMeshClass::ElementDataType.
+   */
+  const auto&
+  get_element_data () const
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    const t8_locidx_t handle_id = this->underlying ().get_element_handle_id ();
+    T8_ASSERTF (static_cast<size_t> (handle_id) < this->underlying ().m_mesh->m_element_data.size (),
+                "Element data not set.\n");
+    return this->underlying ().m_mesh->m_element_data[handle_id];
+  }
+};
+
+}  // namespace t8_mesh_handle
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 78cb844f22..8611a59ae8 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -27,8 +27,9 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 
 #include <t8.h>
-#include <t8_element/t8_element.h>
+#include "data_handler.hxx"
 #include <t8_eclass/t8_eclass.h>
+#include <t8_element/t8_element.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_scheme.hxx>
@@ -60,9 +61,12 @@ namespace t8_mesh_handle
 template <typename TMeshClass, template <typename> class... TCompetences>
 class element: public TCompetences<element<TMeshClass, TCompetences...>>... {
  private:
-  using SelfType
-    = element<TMeshClass, TCompetences...>; /**< Type of the current class with all template parameters specified. */
+  using SelfType = element<TMeshClass, TCompetences...>; /**< Type of the current class with all template
+                                   parameters specified. */
   friend TMeshClass; /**< Define TMeshClass as friend to be able to access e.g. the constructor. */
+  friend struct element_data_element_competence<
+    SelfType>; /**< Define the competence to access element data as friend to
+                    be able to access e.g. the mesh. */
 
   /** Private constructor for an element of a mesh. This could be a simple mesh element or a ghost element.
    *  This constructor should only be called by the TMeshClass (and invisible for the user).
@@ -178,6 +182,15 @@ class element: public TCompetences<element<TMeshClass, TCompetences...>>... {
     return requires (SelfType& element) { element.face_normal_cache_filled (0); };
   }
 
+  /** Function that checks if a competence for element data handling is given to the element.
+   * \return true if element has a data handler, false otherwise.
+   */
+  static constexpr bool
+  has_element_data_handler_competence ()
+  {
+    return requires (SelfType& element) { element.get_element_data (); };
+  }
+
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
   /** Getter for the refinement level of the element.
    *  For this easily accessible variable, it makes no sense to provide a cached version.
@@ -538,38 +551,6 @@ class element: public TCompetences<element<TMeshClass, TCompetences...>>... {
     return m_is_ghost_element;
   }
 
-  // --- Getter and setter for element data. ---
-  /** Getter for the element data.
-   * For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
-   * Element data for non-ghost elements can be accessed (if set) directly.
-   * \return Element data with data of Type TMeshClass::ElementDataType.
-   */
-  template <typename TElementDataType = typename TMeshClass::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  const TElementDataType&
-  get_element_data () const
-  {
-    const t8_locidx_t handle_id = get_element_handle_id ();
-    T8_ASSERTF (static_cast<size_t> (handle_id) < m_mesh->m_element_data.size (), "Element data not set.\n");
-    return m_mesh->m_element_data[handle_id];
-  }
-
-  /** Set the element data for the element. 
-   * \note You can only set element data for non-ghost elements.
-   * \param [in] element_data The element data to be set.
-   */
-  template <typename TElementDataType = typename TMeshClass::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  void
-  set_element_data (TElementDataType element_data)
-  {
-    SC_CHECK_ABORT (!m_is_ghost_element, "Element data cannot be set for ghost elements.\n");
-    // Resize for the case that no data vector has been set previously.
-    m_mesh->m_element_data.reserve (m_mesh->get_num_local_elements () + m_mesh->get_num_ghosts ());
-    m_mesh->m_element_data.resize (m_mesh->get_num_local_elements ());
-    m_mesh->m_element_data[get_element_handle_id ()] = std::move (element_data);
-  }
-
  private:
   // --- Private member variables. ---
   TMeshClass* m_mesh;             /**< Pointer to the mesh the element is defined for. */
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
index ab86c5c618..cf9fce7504 100644
--- a/mesh_handle/internal/competence_pack_union.hxx
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -21,7 +21,8 @@
 */
 
 /** \file competence_pack_union.hxx 
- * Define the implementation of the unique union of competences of several \ref t8_mesh_handle::competence_pack 's.
+ * Define the implementation of the unique union of competences of several \ref t8_mesh_handle::element_competence_pack 's
+ * and \ref t8_mesh_handle::mesh_competence_pack 's.
  * Users should use \ref t8_mesh_handle::union_competence_packs_type in \ref competence_pack.hxx.
  */
 
@@ -32,11 +33,17 @@
 namespace t8_mesh_handle
 {
 
-/** Forward declaration of the competence pack class.
+/** Forward declaration of the element competence pack classes.
  * \tparam TCompetence The competences to be packed.
  */
 template <template <typename> class... TCompetence>
-struct competence_pack;
+struct element_competence_pack;
+
+/** Forward declaration of the mesh competence pack classes.
+ * \tparam TCompetence The competences to be packed.
+ */
+template <template <typename> class... TCompetence>
+struct mesh_competence_pack;
 
 /** Namespace to hide detail from user. */
 namespace detail
@@ -53,35 +60,49 @@ struct tag
 {
 };
 
+/** Check whether a competence is already contained in a competence pack.
+ * This helper compares the given competence TCompetence against a list of competences TUnionCompetences 
+ * using the tag wrapper. 
+ * \tparam TCompetence        Competence to check for.
+ * \tparam TUnionCompetences  Existing competences in the pack.
+ * \return true if TCompetence is already present, and false otherwise.
+ */
+template <template <class> class TCompetence, template <class> class... TUnionCompetences>
+inline constexpr bool contains_tag_v = std::disjunction_v<std::is_same<tag<TCompetence>, tag<TUnionCompetences>>...>;
+
 /** Insert competence TCompetence into a pack with competences TUnionCompetences if not already present.
- * A new competence_pack is produced.
+ * A new competence_pack (element_ or mesh_competence_pack) is produced.
+ * \tparam TPackType         Type of the competence. Should be element_competence_pack or mesh_competence_pack.
  * \tparam TCompetence       Competence to insert.
  * \tparam TUnionCompetences Existing competences in the pack.
  */
-template <template <class> class TCompetence, template <class> class... TUnionCompetences>
-using insert_unique
-  = std::conditional_t<(std::is_same_v<tag<TCompetence>, tag<TUnionCompetences>> || ...),
-                       competence_pack<TUnionCompetences...>, competence_pack<TUnionCompetences..., TCompetence>>;
+template <template <template <typename> class...> class TPackType, template <class> class TCompetence,
+          template <class> class... TUnionCompetences>
+using insert_unique = std::conditional_t<contains_tag_v<TCompetence, TUnionCompetences...>,
+                                         TPackType<TUnionCompetences...>, TPackType<TUnionCompetences..., TCompetence>>;
 
 //--- Unique fold operation to fold competences into one competence pack without duplication. ---
 /** Fold operation to accumulate unique competences.
  * Recursively inserts all TCompetences into the competence pack.
+ * \tparam TPackType       Type of the competence. Should be element_competence_pack or mesh_competence_pack.
  * \tparam TCompetencePack Current accumulated competence_pack.
- * \tparam TCompetences Competences to process.
+ * \tparam TCompetences    Competences to process.
  */
-template <typename TCompetencePack, template <class> class... TCompetences>
+template <template <template <typename> class...> class TPackType, typename TCompetencePack,
+          template <class> class... TCompetences>
 struct fold_unique;
 
 /** Termination case: no more competences to process.
  * Specialization for the case when the competence pack is already fully processed and 
  * no more competences are left to insert.
+ * \tparam TPackType       Type of the competence. Should be element_competence_pack or mesh_competence_pack.
  * \tparam TUnionCompetences Existing competences in the pack.
  */
-template <template <class> class... TUnionCompetences>
-struct fold_unique<competence_pack<TUnionCompetences...>>
+template <template <template <typename> class...> class TPackType, template <class> class... TUnionCompetences>
+struct fold_unique<TPackType, TPackType<TUnionCompetences...>>
 {
   /** Final competence pack with all competences inserted. */
-  using type = competence_pack<TUnionCompetences...>;
+  using type = TPackType<TUnionCompetences...>;
 };
 
 /** Recursive case: insert the first competence uniquely, then process the rest recursively until 
@@ -91,52 +112,73 @@ struct fold_unique<competence_pack<TUnionCompetences...>>
  * \tparam TCompetence Competence to insert in this recursion cycle.
  * \tparam TOtherCompetences Remaining competences to process in the next recursion cycles.
  */
-template <template <class> class... TUnionCompetences, template <class> class TCompetence,
-          template <class> class... TOtherCompetences>
-struct fold_unique<competence_pack<TUnionCompetences...>, TCompetence, TOtherCompetences...>
+template <template <template <typename> class...> class TPackType, template <class> class... TUnionCompetences,
+          template <class> class TCompetence, template <class> class... TOtherCompetences>
+struct fold_unique<TPackType, TPackType<TUnionCompetences...>, TCompetence, TOtherCompetences...>
 {
   /** Competence pack after inserting the first competence TCompetence uniquely. */
-  using type = typename fold_unique<insert_unique<TCompetence, TUnionCompetences...>, TOtherCompetences...>::type;
+  using type = typename fold_unique<TPackType, insert_unique<TPackType, TCompetence, TUnionCompetences...>,
+                                    TOtherCompetences...>::type;
 };
 
 //--- Unique union of two competence packs. ---
-/** Compute the unique union of the competences of two \ref competence_pack 's.
- * This produces a new \ref competence_pack containing all competences with duplicates removed.
+/** Compute the unique union of the competences of two competence_pack 's.
+ * This produces a new competence_pack of the same type (mesh or element competence_pack) containing all 
+ * competences with duplicates removed.
  * \tparam TPack1 First competence pack.
  * \tparam TPack2 Second competence pack.
  */
 template <typename TPack1, typename TPack2>
 struct union_two_competence_packs;
 
-/** Specialization for two \ref competence_pack types. 
+/** Specialization for two \ref t8_mesh_handle::element_competence_pack types. 
+ * This is necessary because this way, we can access the competences directly. 
+ * This specialization of the class above is used if both template parameters are of type 
+ * \ref t8_mesh_handle::element_competence_pack.
+ * \tparam TCompetences1 Competences of the first competence pack.
+ * \tparam TCompetences2 Competences of the second competence pack. 
+ */
+template <template <class> class... TCompetences1, template <class> class... TCompetences2>
+struct union_two_competence_packs<element_competence_pack<TCompetences1...>, element_competence_pack<TCompetences2...>>
+{
+  /** The resulting element_competence_pack type with all competences from both packs, but without duplicates.
+   * The type is computed by folding the unique insertion of all competences from the second pack into pack 1.
+   */
+  using type =
+    typename fold_unique<element_competence_pack, element_competence_pack<TCompetences1...>, TCompetences2...>::type;
+};
+
+/** Specialization for two \ref t8_mesh_handle::mesh_competence_pack types. 
  * This is necessary because this way, we can access the competences directly. 
- * This specialization of the class above is used if both template parameters are of type \ref competence_pack.
+ * This specialization of the class above is used if both template parameters are of type
+ * \ref t8_mesh_handle::mesh_competence_pack.
  * \tparam TCompetences1 Competences of the first competence pack.
  * \tparam TCompetences2 Competences of the second competence pack. 
  */
 template <template <class> class... TCompetences1, template <class> class... TCompetences2>
-struct union_two_competence_packs<competence_pack<TCompetences1...>, competence_pack<TCompetences2...>>
+struct union_two_competence_packs<mesh_competence_pack<TCompetences1...>, mesh_competence_pack<TCompetences2...>>
 {
-  /** The resulting competence_pack type with all competences from both packs, but without duplicates.
-   * The type is computed by folding the unique insertion of all competences from both packs into an 
-   * initially empty pack.
+  /** The resulting mesh_competence_pack type with all competences from both packs, but without duplicates.
+   * The type is computed by folding the unique insertion of all competences from the second pack into pack 1.
    */
-  using type = typename fold_unique<competence_pack<>, TCompetences1..., TCompetences2...>::type;
+  using type =
+    typename fold_unique<mesh_competence_pack, mesh_competence_pack<TCompetences1...>, TCompetences2...>::type;
 };
 
 //--- Recursive union of multiple competence packs using the implementation for two packs. ---
-/** Recursive case: Compute the unique union of the competences of more than one  \ref competence_pack 's.
+/** Recursive case: Compute the unique union of the competences of more than one competence_pack.
+ * This can be \ref t8_mesh_handle::element_competence_pack or \ref t8_mesh_handle::mesh_competence_pack.
  * Specialization for the case when there are still at least two competence packs left to process.
  * Uses \ref union_two_competence_packs recursively for pairwise combination.
  * \tparam TPack First competence pack to combine with the union of the rest of the competence packs 
  *          in this recursion cycle.
  * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
- *         Each competence pack is expected to be of type \ref competence_pack.
+ *         Each competence pack is expected to be of the same type.
  */
 template <typename TPack, typename... TPacks>
 struct union_competence_packs
 {
-  /** This is the type of a new \ref competence_pack containing all competences of the competence packs 
+  /** This is the type of a new competence_pack (mesh or element) containing all competences of the competence packs 
    * with duplicates removed.
    */
   using type = typename union_two_competence_packs<TPack, typename union_competence_packs<TPacks...>::type>::type;
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 6fc25b834d..e707add657 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,12 +30,12 @@
 #include "element.hxx"
 #include "competence_pack.hxx"
 #include "internal/adapt.hxx"
-#include "t8_forest/t8_forest_balance.h"
-#include "t8_forest/t8_forest_types.h"
+#include "data_handler.hxx"
+#include <t8_forest/t8_forest_balance.h>
+#include <t8_forest/t8_forest_types.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>
-#include <type_traits>
 #include <functional>
 #include <memory>
 #include <span>
@@ -43,35 +43,37 @@
 namespace t8_mesh_handle
 {
 
-/** Concept to ensure that a type is MPI safe.
+/** Concept to ensure that a type is an element competence pack.
  */
 template <typename TType>
-concept T8MPISafeType
-  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
+concept ElementCompetencePack = requires { typename TType::is_element_competence_pack; };
+/** Concept to ensure that a type is a mesh competence pack.
+ */
+template <typename TType>
+concept MeshCompetencePack = requires { typename TType::is_mesh_competence_pack; };
 
 /**
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
- * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
+ * \tparam TElementCompetencePack The competences you want to add to the default functionality of the elements.
  *         \see element for more details on the choice of the template parameter.   
- *         \note Please pack your competences using the \ref competence_pack class.
- * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
- *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
- *         Use void (this is also the default) if you do not want to set element data.
+ *         \note Please pack your competences using the \ref element_competence_pack class.
+ * \tparam TMeshCompetences The competences you want to add to the default functionality of the mesh.  
+ *         \note Please pack your competences using the \ref t8_mesh_handle::mesh_competence_pack class.
+ *         One of the most important competences to add is \ref element_data_mesh_competence.
  */
-template <typename TCompetencePack = competence_pack<>, T8MPISafeType TElementDataType = void>
-class mesh {
+template <ElementCompetencePack TElementCompetencePack = element_competence_pack<>,
+          MeshCompetencePack TMeshCompetencePack = mesh_competence_pack<>>
+class mesh: public TMeshCompetencePack::template apply<mesh<TElementCompetencePack, TMeshCompetencePack>> {
  public:
-  using SelfType
-    = mesh<TCompetencePack, TElementDataType>; /**< Type of the current class with all template parameters specified. */
-  using ElementDataType = TElementDataType;    /**< Make Type of the element data accessible. */
-  using element_class =
-    typename TCompetencePack::template apply<SelfType,
-                                             element>; /**< The element class of the mesh with given competences. */
+  using SelfType = mesh<TElementCompetencePack, TMeshCompetencePack>; /**< Type of the current class. */
+  using element_class = typename TElementCompetencePack::template apply<
+    SelfType, element>; /**< The element class of the mesh with given competences. */
   friend element_class; /**< Element class as friend such that private members (e.g. the forest) can be accessed. */
   using mesh_const_iterator =
     typename std::vector<element_class>::const_iterator; /**< Constant iterator type for the mesh elements. */
   using mesh_iterator =
-    typename std::vector<element_class>::iterator; /**< Non-const iterator type for the mesh elements. */
+    typename std::vector<element_class>::iterator;              /**< Non-const iterator type for the mesh elements. */
+  friend struct element_data_element_competence<element_class>; /**< Friend struct to access its element data vector. */
 
   /** Callback function prototype to decide for refining and coarsening of a family of elements
    * or one element in a mesh handle.
@@ -110,7 +112,6 @@ class mesh {
    */
   mesh (t8_forest_t forest): m_forest (forest)
   {
-    T8_ASSERT ((std::is_same<typename TCompetencePack::is_competence_pack, void>::value));
     T8_ASSERT (t8_forest_is_committed (m_forest));
     update_elements ();
   }
@@ -376,7 +377,7 @@ class mesh {
     // Check if we adapted and unregister the adapt context if so.
     if (detail::adapt_registry::get (m_uncommitted_forest.value ()) != nullptr) {
       detail::adapt_registry::unregister_context (m_forest);
-      if (!std::is_void<TElementDataType>::value) {
+      if constexpr (has_element_data_handler_competence ()) {
         t8_global_infof (
           "Please note that the element data is not interpolated automatically during adaptation. Use the "
           "function set_element_data() to provide new adapted element data.\n");
@@ -389,56 +390,14 @@ class mesh {
     update_elements ();
   }
 
-  // --- Methods to set and get user and element data and exchange data between processes. ---
-  /** 
-   * Set the element data vector. The vector should have the length of num_local_elements.
-   * \param [in] element_data The element data vector to set with one entry of class TElementDataType 
-   *            for each local mesh element (excluding ghosts).
-   */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  set_element_data (std::vector<ElementDataType> element_data)
-  {
-    T8_ASSERT (element_data.size () == static_cast<size_t> (get_num_local_elements ()));
-    m_element_data = std::move (element_data);
-    m_element_data.reserve (get_num_local_elements () + get_num_ghosts ());
-    m_element_data.resize (get_num_local_elements ());
-  }
-
-  /** 
-   * Get the element data vector.
-   * The element data of the local mesh elements can be set using \ref set_element_data.
-   * If ghost entries should be filled, one should call \ref exchange_ghost_data on each process first.
-   * \return Element data vector with data of Type TElementDataType.
+  // --- Methods to check for mesh competences. ---
+  /** Function that checks if a competence for element data handling is given.
+   * \return true if mesh has a data handler, false otherwise.
    */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  const std::vector<ElementDataType>&
-  get_element_data () const
+  static constexpr bool
+  has_element_data_handler_competence ()
   {
-    return m_element_data;
-  }
-
-  /** 
-  * Exchange the element data for ghost elements between processes.
-  * This routine has to be called on each process after setting the element data for all local elements.
-  */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  exchange_ghost_data ()
-  {
-    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
-    sc_array* sc_array_wrapper;
-    m_element_data.resize (get_num_local_elements () + get_num_ghosts ());
-    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType),
-                                          get_num_local_elements () + get_num_ghosts ());
-
-    // Data exchange: entries with indices > num_local_elements will get overwritten.
-    t8_forest_ghost_exchange_data (m_forest, sc_array_wrapper);
-
-    sc_array_destroy (sc_array_wrapper);
+    return requires (SelfType& mesh) { mesh.get_element_data (); };
   }
 
  private:
@@ -485,8 +444,6 @@ class mesh {
   t8_forest_t m_forest;                  /**< The forest the mesh should be defined for. */
   std::vector<element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<element_class> m_ghosts;   /**< Vector storing the (local) ghost elements. */
-  std::conditional_t<!std::is_void_v<TElementDataType>, std::vector<TElementDataType>, std::nullptr_t>
-    m_element_data; /**< Vector storing the (local) element data. */
   std::optional<t8_forest_t>
     m_uncommitted_forest; /**< Forest in which the set flags are set for a new forest before committing. */
 };
diff --git a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
index 4a04b9f12e..bdb773ba08 100644
--- a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
+++ b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
@@ -33,7 +33,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8.h>
 
 #include <mesh_handle/mesh.hxx>
-#include <mesh_handle/competence_pack.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -110,7 +110,7 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_forest)
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
   const t8_scheme *init_scheme = t8_scheme_new_default ();
   t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  using mesh_class = t8_mesh_handle::mesh<>;
   mesh_class mesh_handle = mesh_class (forest);
   struct dummy_user_data user_data = {
     t8_3D_vec ({ 0.5, 0.5, 1 }), /**< Midpoints of the sphere. */
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 49d1338401..218e176728 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -145,7 +145,7 @@ struct cache_face_normals_overwrite: public t8_mesh_handle::cache_face_normals<T
 TEST (t8_gtest_cache_competence, cache_volume)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_volume_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
@@ -172,7 +172,7 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_diameter_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_diameter_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
@@ -194,7 +194,7 @@ TEST (t8_gtest_cache_competence, cache_diameter)
 TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_vertex_coordinates_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
@@ -220,7 +220,7 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 TEST (t8_gtest_cache_competence, cache_centroid)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_centroid_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
@@ -245,7 +245,7 @@ TEST (t8_gtest_cache_competence, cache_centroid)
 TEST (t8_gtest_cache_competence, cache_face_areas)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_areas_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_areas_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_areas_cache ());
@@ -270,7 +270,7 @@ TEST (t8_gtest_cache_competence, cache_face_areas)
 TEST (t8_gtest_cache_competence, cache_face_centroids)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_centroids_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_centroids_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_centroids_cache ());
@@ -296,7 +296,7 @@ TEST (t8_gtest_cache_competence, cache_face_centroids)
 TEST (t8_gtest_cache_competence, cache_face_normals)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_normals_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_face_normals_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_normals_cache ());
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 5af812a3d7..4777eecb45 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -83,7 +83,7 @@ TEST (t8_gtest_custom_competence, custom_competence)
 {
   const int level = 1;
   // Check mesh with custom defined competence.
-  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
+  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<dummy_get_level>>;
   const auto mesh
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
@@ -93,7 +93,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // Test with two custom competences and a predefined competence.
-  using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using competences
+    = t8_mesh_handle::element_competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
   using mesh_class = t8_mesh_handle::mesh<competences>;
   auto mesh_more_competences
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 5b5bceb2b6..c26db84c42 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -59,7 +59,7 @@ struct t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_element_competences>;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             false, false);
 
@@ -194,7 +194,7 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
  */
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_neighbors_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD,
                                                                                   true, true, false);
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 3066e7b506..ff370d612c 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
 #include <mesh_handle/constructor_wrappers.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
@@ -46,7 +47,8 @@ struct data_per_element
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   const int level = 2;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences, data_per_element>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::data_element_competences,
+                                          t8_mesh_handle::data_mesh_competences<data_per_element>>;
   auto mesh
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
 
@@ -70,13 +72,15 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
   }
 
   // Modify element data for elements that are in the first half of the global trees.
+  EXPECT_TRUE (mesh->has_element_data_handler_competence ());
   auto forest = mesh->get_forest ();
   t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
   const int newlevel = 42;
   const double newvolume = 42.42;
   for (auto &elem : *mesh) {
     if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
-      elem.set_element_data ({ newlevel, newvolume });
+      data_per_element elem_data ({ newlevel, newvolume });
+      elem.set_element_data (elem_data);
     }
   }
   mesh->exchange_ghost_data ();
@@ -105,3 +109,22 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
     }
   }
 }
+
+/** Check that the unique union of multiple mesh competence packs works as intended. 
+ * This is done in this file because there is only one mesh competence at the moment, where we need a data class. 
+ * We use the data class defined here. 
+ */
+TEST (t8_gtest_handle_data, test_union_mesh_competence_pack)
+{
+  using namespace t8_mesh_handle;
+  using mesh_class = mesh<
+    union_competence_packs_type<all_cache_element_competences, data_element_competences, empty_element_competences>,
+    union_competence_packs_type<data_mesh_competences<data_per_element>, data_mesh_competences<data_per_element>,
+                                empty_mesh_competences>>;
+  EXPECT_TRUE (mesh_class::has_element_data_handler_competence ());
+  using element_class = typename mesh_class::element_class;
+
+  EXPECT_TRUE (element_class::has_element_data_handler_competence ());
+  EXPECT_TRUE (element_class::has_volume_cache ());
+  EXPECT_TRUE (element_class::has_diameter_cache ());
+}
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index eb77fe86c7..c7f7cac258 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -22,7 +22,8 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 /**
  * \file t8_gtest_mesh_handle.cxx
- * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended for different types of template parameter classes. 
+ * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended
+ * for different types of template parameter classes.
  */
 
 #include <gtest/gtest.h>
@@ -86,7 +87,7 @@ TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
 TEST_P (t8_mesh_handle_test, test_all_cache_competence)
 {
   // --- Use predefined competences to use all available caching competences. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_element_competences>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);
@@ -133,7 +134,7 @@ TEST_P (t8_mesh_handle_test, test_all_cache_competence)
 /** Test mesh class with all predefined face competences using some exemplary functionality. */
 TEST_P (t8_mesh_handle_test, test_cache_face_competences)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_element_competences>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);
@@ -172,16 +173,17 @@ TEST_P (t8_mesh_handle_test, test_cache_face_competences)
 }
 
 /** Check that the unique union of multiple competence packs works as intended. */
-TEST (t8_mesh_handle_test, test_union_competence_pack)
+TEST (t8_mesh_handle_test, test_union_element_competence_pack)
 {
   using namespace t8_mesh_handle;
   /* Combine multiple competence packs with some overlapping competences to check that the union works correctly
    * and duplicates are removed. Duplicates would cause an error because we inherit multiple times from the same class.
    */
-  using mesh_class
-    = mesh<union_competence_packs_type<competence_pack<cache_volume>,
-                                       competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates>,
-                                       competence_pack<cache_centroid, cache_face_areas, cache_face_centroids>>>;
+  using mesh_class = mesh<union_competence_packs_type<
+    element_competence_pack<cache_volume>,
+    element_competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates>,
+    element_competence_pack<cache_volume, cache_centroid, cache_face_areas, cache_face_centroids>,
+    empty_element_competences>>;
   using element_class = typename mesh_class::element_class;
 
   EXPECT_TRUE (element_class::has_volume_cache ());