diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml
index 2648f684..041ab035 100644
--- a/.github/workflows/codespell.yml
+++ b/.github/workflows/codespell.yml
@@ -6,8 +6,8 @@ on:
     - main
 
   pull_request:
-    branches:
-    - main
+    #branches:
+    #- main
   workflow_dispatch:
 
 jobs:
diff --git a/.github/workflows/doxygen-build.yml b/.github/workflows/doxygen-build.yml
index 7c034e07..7ebe4d69 100644
--- a/.github/workflows/doxygen-build.yml
+++ b/.github/workflows/doxygen-build.yml
@@ -2,8 +2,8 @@ name: Doxygen build test
 
 on:
   pull_request:
-    branches:
-    - main
+    #branches:
+    #- main
 
 jobs:
   test:
@@ -17,7 +17,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: "true"
-      
+
       - name: Install dependencies - macos
         run: brew install hdf5 boost catch2 doxygen graphviz
 
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 87149c11..a0bd18b2 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -6,8 +6,8 @@ on:
     - main
 
   pull_request:
-    branches:
-    - main
+    #branches:
+    #- main
   workflow_dispatch:
 
 jobs:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 0c3ac824..10542a7f 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -6,8 +6,8 @@ on:
     - main
 
   pull_request:
-    branches:
-    - main
+    #branches:
+    #- main
   workflow_dispatch:
 
 jobs:
@@ -22,7 +22,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, ubuntu-latest]
-    
+
     runs-on: ${{ matrix.os }}
 
     steps:
@@ -39,7 +39,7 @@ jobs:
         git checkout "v3.5.3"
         cmake -Bbuild -H. -DBUILD_TESTING=OFF
         sudo cmake --build build/ --target install
-    
+
     - name: Install dependencies - macos
       if: matrix.os == 'macos-latest'
       run: brew install hdf5 boost catch2
@@ -67,7 +67,7 @@ jobs:
 
   sanitize:
     needs: test
-    
+
     runs-on: ubuntu-latest
 
     steps:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 86fc42cf..5e5fa408 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,9 +19,10 @@ include(cmake/variables.cmake)
 
 add_library(
     aqnwb_aqnwb
-    src/BaseIO.cpp
+    src/io/BaseIO.cpp
     src/Channel.cpp
-    src/hdf5/HDF5IO.cpp
+    src/io/hdf5/HDF5IO.cpp
+    src/io/hdf5/HDF5RecordingData.cpp
     src/nwb/NWBFile.cpp
     src/nwb/RecordingContainers.cpp
     src/nwb/base/TimeSeries.cpp
diff --git a/docs/Doxyfile.in b/docs/Doxyfile.in
index 17824788..b62c2079 100644
--- a/docs/Doxyfile.in
+++ b/docs/Doxyfile.in
@@ -14,6 +14,10 @@ EXTRACT_ALL = YES
 RECURSIVE = YES
 OUTPUT_DIRECTORY = "@DOXYGEN_OUTPUT_DIRECTORY@"
 
+# Also show private members in the docs,
+EXTRACT_PRIVATE = YES
+# HIDE_UNDOC_MEMBERS = YES
+
 # Enable Markdown support
 MARKDOWN_SUPPORT = YES
 
diff --git a/docs/pages/1_userdocs.dox b/docs/pages/1_userdocs.dox
index ec3784fb..8481b21a 100644
--- a/docs/pages/1_userdocs.dox
+++ b/docs/pages/1_userdocs.dox
@@ -7,4 +7,5 @@
  * - \subpage user_install_page
  * - \subpage workflow
  * - \subpage hdf5io
+ * - \subpage read_page
  */
diff --git a/docs/pages/devdocs/documentation.dox b/docs/pages/devdocs/documentation.dox
index 8a026761..0b087ea1 100644
--- a/docs/pages/devdocs/documentation.dox
+++ b/docs/pages/devdocs/documentation.dox
@@ -69,7 +69,7 @@
  *
  *  To display a code snippet from our example in the documentation we can use the
  *  ``\snippet <file> <label>`` Doxygen command in our ``*.dox`` documentation file.
- *  For example to just show the line where we create the \ref AQNWB::HDF5::HDF5IO "HDF5IO
+ *  For example to just show the line where we create the \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO"
  *  object we use:
  *
  * \code{.sh}
diff --git a/docs/pages/userdocs/hdf5io.dox b/docs/pages/userdocs/hdf5io.dox
index 263e0f3b..761af080 100644
--- a/docs/pages/userdocs/hdf5io.dox
+++ b/docs/pages/userdocs/hdf5io.dox
@@ -96,7 +96,7 @@
  *
  * \section hdf5io_swmr Single-Writer Multiple-Reader (SWMR) Mode
  *
- * The \ref AQNWB::HDF5::HDF5IO "HDF5IO" I/O backend uses by default SWMR mode while recording data.
+ * The \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO" I/O backend uses by default SWMR mode while recording data.
  * Using SWMR, one process can write to the HDF5 file and multiple other processes can read
  * from the file concurrently while ensuring that the readers see a consistent view of the data.
  *
@@ -106,7 +106,7 @@
  *     node [shape=box, style=filled];
  *
  *     // Define the writer node with light blue fill color
- *     writer [label="AqNWB HDF5IO\n(SWMR Write)", fillcolor=lightblue, URL="\ref AQNWB::HDF5::HDF5IO"];
+ *     writer [label="AqNWB HDF5IO\n(SWMR Write)", fillcolor=lightblue, URL="\ref AQNWB::IO::HDF5::HDF5IO"];
  *     // Define the HDF5 file node with a distinct shape
  *     hdf5_file [label="\n.nwb\n(HDF5 File)\n ", shape=folder, fillcolor=lightgray, URL="\ref AQNWB::NWB::NWBFile"];
  *     // Define reader nodes with light green fill color
@@ -148,11 +148,11 @@
  * \note
  * While SWMR mode ensures data integrity, some data loss may still occur if the application crashes.
  * Only data that has been completely written and flushed to disk will be readable. To manually
- * flush data to disk use \ref AQNWB::HDF5::HDF5IO::flush  "HDF5IO::flush".
+ * flush data to disk use \ref AQNWB::IO::HDF5::HDF5IO::flush  "HDF5IO::flush".
  *
  * \subsection  hdf5io_swmr_workflow Writing an NWB file with SWMR mode
  *
- * SWMR mode is enabled when calling \ref AQNWB::HDF5::HDF5IO::startRecording "HDF5IO::startRecording".
+ * SWMR mode is enabled when calling \ref AQNWB::IO::HDF5::HDF5IO::startRecording "HDF5IO::startRecording".
  * Once SWMR mode is enabled, no new data objects (Datasets, Groups, Attributes etc.)
  * can be created, but we can only add and set values to existing data objects. Since other
  * processes may read from the HDF5 file, it is not possible to intermittently disable
@@ -168,7 +168,7 @@
  * This workflow is applicable to a wide range of data acquisition use-cases. However,
  * for use cases that require creation of new Groups and Datasets during acquisition,
  * you can disable the use of SWMR mode by setting `disableSWMRMode=true` when
- * constructing the \ref AQNWB::HDF5::HDF5IO object.
+ * constructing the \ref AQNWB::IO::HDF5::HDF5IO object.
  *
  * \warning
  * While disabling SWMR mode allows Groups and Datasets to be created during and after
diff --git a/docs/pages/userdocs/read.dox b/docs/pages/userdocs/read.dox
new file mode 100644
index 00000000..a26774a9
--- /dev/null
+++ b/docs/pages/userdocs/read.dox
@@ -0,0 +1,360 @@
+/**
+ * \page read_page Reading data
+ *
+ * \tableofcontents
+ *
+ * \section read_design_intro Introduction
+ *
+ * Reading data from an open NWB file via AqNWB consists of two main steps. In the
+ * first step we retrieve a wrapper object that provides lazy read access to the
+ * particular dataset or attribute:
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_data_wrapper_snippet
+ *
+ * In the second step we then request the parts of the data we are interested in,
+ * at which point the data is being loaded from disk.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_datablock_snippet
+ *
+ * In the following sections we dive deeper into the \ref read_design_sec, describing
+ * the different classes involved in reading data and their responsibilities. We then
+ * show a more detailed \ref read_design_example to illustrate how read works in the
+ * overall context of data acquisition.
+ *
+ *
+ * \section read_design_sec Software Design
+ *
+ * The following figure shows the main classes involved with reading data from a dataset or attribute.
+ *
+ * @dot
+ * digraph G {
+ *     node [shape=none];
+ *
+ *     HDF5IO [
+ *         label=<
+ *             <table border="0" cellborder="1" cellspacing="0">
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>HDF5IO</b></td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Functions</b></td></tr>
+ *                 <tr><td align="left">+ readDataset(): DataBlockGeneric</td></tr>
+ *                 <tr><td align="left">+ readAttribute(): DataBlockGeneric</td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Attributes</b></td></tr>
+ *             </table>
+ *         >
+ *     ];
+ *
+ *     NWBFile [
+ *         shape=note,
+ *         label="NWB file (HDF5)"
+ *     ];
+ *
+ *     DataBlockGeneric [
+ *         label=<
+ *             <table border="0" cellborder="1" cellspacing="0">
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>DataBlockGeneric</b></td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Functions</b></td></tr>
+ *                 <tr><td align="left">+ getData(): void</td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Attributes</b></td></tr>
+ *                 <tr><td align="left">+ data: std::any</td></tr>
+ *                 <tr><td align="left">+ shape: std::vector&lt;SizeType&gt;</td></tr>
+ *             </table>
+ *         >
+ *     ];
+ *
+ *     ReadDataWrapper [
+ *         label=<
+ *             <table border="0" cellborder="1" cellspacing="0">
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>ReadDataWrapper</b></td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Functions</b></td></tr>
+ *                 <tr><td align="left">+ valuesGeneric(): DataBlockGeneric</td></tr>
+ *                 <tr><td align="left">+ values(): DataBlock</td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Attributes</b></td></tr>
+ *                 <tr><td align="left">+ io: const std::shared_ptr&lt;BaseIO&gt;</td></tr>
+ *                 <tr><td align="left">+ dataPath: std::string</td></tr>
+ *             </table>
+ *         >
+ *     ];
+ *
+ *     DataBlock [
+ *         label=<
+ *             <table border="0" cellborder="1" cellspacing="0">
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>DataBlock</b></td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Functions</b></td></tr>
+ *                 <tr><td align="left">+ fromGeneric(): DataBlock</td></tr>
+ *                 <tr><td align="left">+ as_multi_array(): MultiArray</td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Attributes</b></td></tr>
+ *                 <tr><td align="left">+ data: std::vector&lt;DTYPE&gt;</td></tr>
+ *                 <tr><td align="left">+ shape: std::vector&lt;SizeType&gt;</td></tr>
+ *             </table>
+ *         >
+ *     ];
+ *
+ *     Container [
+ *         label=<
+ *             <table border="0" cellborder="1" cellspacing="0">
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Container</b></td></tr>
+ *                 <tr><td colspan="2" bgcolor="lightgray"><b>Attributes</b></td></tr>
+ *                 <tr><td align="left">+ io: std::shared_ptr&lt;BaseIO&gt;</td></tr>
+ *                 <tr><td align="left">+ path: std::string</td></tr>
+ *             </table>
+ *         >
+ *     ];
+ *
+ *     { rank=same; Container; }
+ *     { rank=same; DataBlock; ReadDataWrapper; DataBlockGeneric; }
+ *     { rank=same; HDF5IO; }
+ *     { rank=same; NWBFile; }
+ *
+ *     Container -> ReadDataWrapper [label="create"];
+ *     ReadDataWrapper -> DataBlockGeneric [label="return\ndata"];
+ *     ReadDataWrapper -> DataBlock [label="return\ndata"];
+ *     DataBlock -> DataBlockGeneric [label="created\nfrom"];
+ *     ReadDataWrapper -> HDF5IO [label="call readDataset\nor readAttribute"];
+ *     HDF5IO -> NWBFile [label="read data"];
+ * }
+ * @enddot
+ *
+ *
+ * The main components involved in reading data from an NWB file via AqNWB are:
+ *
+ * - \ref AQNWB::IO::BaseIO "BaseIO", \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO" responsible for
+ *   reading data from disk and allocating memory for data on read
+ * - \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric" represents a generic, n-dimensional block of data
+ *   loaded from a file, storing the data as a generic ``std::any`` along with the ``shape`` of the data.
+ *   - \ref AQNWB::IO::DataBlock "DataBlock" represents a typed, n-dimensional block of data, derived
+ *     from a \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric"
+ * - \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper", is a simple wrapper class that represents
+ *   a dataset/attribute for read, enabling lazy data read and allowing for transparent use of different I/O backends.
+ * - \ref AQNWB::NWB::Container "Container" type classes represent Groups with an assigned ``neurodata_type``
+ *   in the NWB format, and are responsible for providing access to the datasets/attributes that they own.
+ *   To provide access, these classes create \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper"
+ *    objects for the user for lazy read access to the data.
+ *
+ * We will discuss these different components in a bit more detail next.
+ *
+ * \subsection read_design_wrapper_container Container
+ *
+ * The \ref AQNWB::NWB::Container "Container" class (e.g., \ref AQNWB::NWB::ElectricalSeries "ElectricalSeries"
+ * or  \ref AQNWB::NWB::NWBFile "NWBFile") is responsible for exposing read access to its
+ * specific datasets and attributes by providing appropriate access functions, which return
+ * \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper<AQNWB::Types::StorageObjectType::Dataset>" or
+ * \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper<AQNWB::Types::StorageObjectType::Attribute>" objects
+ * for lazily reading from the dataset/attribute.
+ *
+ * \subsection read_design_wrapper_propos ReadDataWrapper
+ *
+ * The  \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper" stores a shared pointer
+ * \ref AQNWB::IO::ReadDataWrapper::io "io" to the  I/O object and the
+ * \ref AQNWB::IO::ReadDataWrapper::dataPath "dataPath" to the dataset.
+ *
+ * The \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "valuesGeneric" method then allows us
+ * to read all or parts of the dataset into memory as ``std::any``. This function uses
+ * the \ref AQNWB::IO::BaseIO::readDataset "readDataset" method of the I/O backend
+ * (e.g.,  \ref AQNWB::IO::HDF5::HDF5IO::readDataset "HDF5IO.readDataset") to load the data.
+ * The I/O backend in turn takes care of allocating the memory for the
+ * appropriate data type and loading the data from disk.
+ *
+ * We can retrieve data directly with the appropriate type  by using the templated
+ * \ref AQNWB::IO::ReadDataWrapper::values "values" function instead, which
+ * uses  \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "valuesGeneric" and then
+ * automatically casts the data to a typed  \ref AQNWB::IO::DataBlock "DataBlock<DTYPE>"
+ * instead of returning an untyped  \ref AQNWB::IO::DataBlock "DataBlockGeneric".
+ *
+ * \note
+ *  \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper" takes two template parameters:
+ *  1) the ``OTYPE`` specifying the type of object being wrapped \ref AQNWB::Types::StorageObjectType
+ * and 2) the ``VTYPE`` defining the value type of the data.
+ * For attributes, slicing is disabled at compile time, i.e., attributes are always
+ * loaded fully into memory since attributes are intended for small data only.
+ *
+ * \subsection read_design_data_block DataBlockGeneric and DataBlock
+ *
+ * At first, data values are always represented as a \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric"
+ * object, which stores the \ref AQNWB::IO::DataBlockGeneric::data "data" as ``std::any``
+ * along with the  \ref AQNWB::IO::DataBlockGeneric::shape "shape" of the data. For example,
+ * \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "ReadDatasetWrapper.valuesGeneric"
+ * and \ref AQNWB::IO::HDF5::HDF5IO::readDataset "HDF5IO.readDataset" return
+ * a  \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric". This has the advantage that
+ * we can let the backend handle memory allocation and typing for us and load data
+ * even if we don't know the type yet.
+ *
+ * \subsubsection read_design_data_block_typed DataBlock with typed data
+ *
+ * To cast the data to the appropriate specific type (e.g., ``float``) we can then create a
+ * \ref AQNWB::IO::DataBlock "DataBlock" with the appropriate data type via the
+ * \ref AQNWB::IO::DataBlock::fromGeneric "DataBlock.fromGeneric" factory method. \ref AQNWB::IO::DataBlock "DataBlock"
+ * is templated on the specific data type, i.e., we call ``DataBlock<float>.fromGeneric(myGenericDataBlock)``.
+ * \ref AQNWB::IO::DataBlock "DataBlock" then stores the \ref AQNWB::IO::DataBlock::data "data" as an
+ * appropriately typed 1-dimensional ``std::vector`` along with the \ref AQNWB::IO::DataBlock::shape "shape"
+ * of the data.
+ *
+ * \note
+ * The \ref AQNWB::IO::DataBlock::fromGeneric "DataBlock.fromGeneric" (and
+ * \ref AQNWB::IO::DataBlock::as_multi_array "DataBlock.as_multi_array") use casting
+ * and referencing to transform the data without making additional copies
+ * of the data.
+ *
+ * \subsubsection read_design_data_block_multiarray Using Boost Multi Array for N-Dimensional Data
+ *
+ * To simplify access to multi-dimensional data, we can then represent the data
+ * as a ``BOOST::multi_array``. The \ref AQNWB::IO::DataBlock::as_multi_array "DataBlock.as_multi_array"
+ * convenience method generates a ``boost::const_multi_array_ref<DTYPE, NDIMS>`` for us.
+ * Here the  ``DTYPE`` template parameter is the same as for the \ref AQNWB::IO::DataBlock "DataBlock"
+ * (so that we don't have to specify it again), and the ``NDIMS`` template parameter
+ * is the number of dimensions (which is the same as \ref AQNWB::IO::DataBlock::shape "shape.size()").
+ *
+ * \note
+ * Since we are in a strongly typed language, we here need to know the ``DTYPE`` at compile time
+ * when using \ref AQNWB::IO::DataBlock "DataBlock". And if we want to use the
+ * \ref AQNWB::IO::DataBlock::as_multi_array "DataBlock.as_multi_array", then we also need to know
+ * the number of dimensions ``NDIMS`` at compile time.
+ *
+ *
+ * \subsection read_design_wrapper_io I/O
+ *
+ * The I/O backend is responsible for implementing the actual
+ * \ref AQNWB::IO::BaseIO::readDataset "readDataset" and \ref AQNWB::IO::BaseIO::readAttribute "readAttribute"
+ * methods used for reading data from disk. The methods are also responsible for
+ * allocating appropriate memory with the respective data type. The functions
+ * return the data as \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric", which
+ * stores the data as untyped ``std::any``. The user can then cast the
+ * data to the appropriate type as discussed in \ref read_design_data_block_typed.
+ *
+ *
+ *
+ * \section read_design_example Example
+ *
+ * \subsection read_design_example_create Create a NWB file as usual
+ *
+ * \paragraph read_design_example_step_1 Setup mock data for write
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_mockdata_snippet
+ *
+ * \paragraph read_design_example_step_1_2 Create the NWBFile and record data
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_create_file_snippet
+ *
+ * \subsection read_design_example_read_during Read data during recording
+ *
+ * \paragraph read_design_example_laxy_read Lazy data access
+ *
+ * All data read is implemented lazily, i.e., AqNWB does not load data into memory
+ * until we make a request to do so. To access data lazily, datasets and attributes are
+ * wrapped via \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper" with appropriate
+ * ``OTYPE`` object type template parameter set.
+ * The \ref AQNWB::NWB::Container "Container" object that owns the dataset/attribute then
+ * provides accessor methods to get access to the dataset/attribute. Here, we
+ * access the ``data`` dataset of the \ref AQNWB::NWB::ElectricalSeries "ElectricalSeries".
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_data_wrapper_snippet
+ *
+ * \paragraph read_design_example_load_data Read data into memory
+ *
+ * To access the data values of a data, we can then use the \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "valuesGeneric"
+ * and \ref AQNWB::IO::ReadDataWrapper::values "values" methods, which load the data as generic (untyped) or typed
+ * data, respectively.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_datablock_snippet
+ *
+ * The data is here represented as a \ref AQNWB::IO::DataBlock "DataBlock", which stores the data as 1-dimensional
+ * vector along with the shape of the data. E.g, here we validate the data against the original mock data:
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_validate_datablock_snippet
+ *
+ * \paragraph read_design_example_boostarray Accessing multi-dimensional data as Boost multi-array
+ *
+ * To ease interaction with mutli-dimensional data, e.g., the ``(time x channel)`` data of our
+ * \ref AQNWB::NWB::ElectricalSeries "ElectricalSeries", we can use the
+ * \ref AQNWB::IO::DataBlock::as_multi_array "DataBlock.as_multi_array" method to construct a
+ * ``boost::const_multi_array_ref``.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_boostarray_snippet
+ *
+ * Using boost multi-array simplifies access and interaction with the data as a multi-dimensional array.
+ * Here we use this again to validate the data we loaded against the original mock, like we did above.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_validate_boostarray_snippet
+ *
+ * \paragraph read_design_example_attribute Reading an attribute
+ *
+ * Reading an ``Attribute`` from a file works much in the same way as reading a ``Dataset``.
+ * The main differences are when we read an attribute:
+ * 1. The  \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper" is created with
+ *    the \ref AQNWB::Types::StorageObjectType "AQNWB::Types::StorageObjectType::Attribute" template type
+ *    instead of  \ref AQNWB::Types::StorageObjectType "AQNWB::Types::StorageObjectType::Dataset"
+ * 2. The variants of \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "valuesGeneric"
+ *    or \ref AQNWB::IO::ReadDataWrapper::values "values" that accept arguments for
+ *    slicing are disabled at compile time.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_attribute_snippet
+ *
+ * \note
+ * In this case, the NWB specifies ``float32`` as the dtype for the ``resolution`` attribute.
+ * As such, the template parameter for the ``VTYPE`` (value type) template parameter
+ * for \ref AQNWB::IO::ReadDataWrapper "ReadAttributeWrapper<OTYPE, VTYPE>" is set to ``float``
+ * by default, so we do not need to specify it. If for some reason a file should use
+ * ``float64`` instead, then we can still set the ``VTYPE`` accordingly via
+ * ``electricalSeries->resolutionLazy<float64>()``.
+ *
+ * \note
+ * If we don't want to specify the ``DataBlock<float>``, then we can also
+ * infer the return type of the ``values()`` function at compile time via
+ * ``decltype(readResolutionWrapper->values()) resolutionValueFloat = readResolutionWrapper->values();``
+ *
+ * \paragraph read_design_example_readgeneric Reading data with unknown type
+ *
+ * So far we read data by specifying the ``VTYPE`` template parameter of the read wrapper.
+ * However, if we do not know (or want to) specify the ``VTYPE`` then we can set it to ``std::any``,
+ * which is the default for data with variable type, e.g.
+ * \ref AQNWB::NWB::ElectricalSeries::dataLazy "ElectricalSeries::dataLazy". In this case, we can
+ * still read the data via the \ref AQNWB::IO::ReadDataWrapper::valuesGeneric "valuesGeneric"
+ * to load the data first in untyped form. When loading the data, the I/O backend determines
+ * the data type and allocates memory appropriately. The actual data type is then stored
+ * in \ref AQNWB::IO::DataBlockGeneric::typeIndex "typeIndex" variable of our data block.
+ * We can then convert our \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric" to a
+ * \ref AQNWB::IO::DataBlock "DataBlock<DTYPE>" with a specific data type via
+ * \ref AQNWB::IO::DataBlock::fromGeneric "DataBlock.fromGeneric()".
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_get_data_wrapper_as_generic_snippet
+ *
+ * \note
+ * In most cases, we should not need runtime checking of types in the context of
+ * specific data acquisition systems. This is likely mostly relevant if one wants to consume
+ * arbitrary NWB files that may use different data types. One approach to implement
+ * behavior for types determined at runtime is to define a mapping of the type
+ * information to the corresponding statically type functionality, e.g., via
+ * ``switch/case`` logic or by using a map for lookup, such as:
+ *
+ * \code{.cpp}
+ * DataBlockGeneric dataValuesGeneric = readDataWrapperGeneric->valuesGeneric();
+ * // Map to associate std::type_index with corresponding type-specific functions
+ * std::unordered_map<std::type_index, std::function<void(const DataBlockGeneric&)>> typeMap = {
+ *       {typeid(float), processData<float>},
+ *       {typeid(int), processData<<int>},
+ *       // Add more types as needed
+ * };
+ * // Use the map to process the data with the approbriate type
+ * auto it = typeMap.find(dataValuesGeneric.typeIndex);
+ * if (it != typeMap.end()) {
+ *       it->second(dataValuesGeneric); // call the correct proceesData function
+ * } else {
+ *       std::cout << "Unsupported type" << std::endl;
+ * }
+ * \endcode
+ *
+ * \subsection read_design_example_stop_recording Finalize the recording
+ *
+ * Next we stop the recording and close the file so we can show how we can read from the file
+ * we just created.
+ *
+ * \snippet tests/examples/test_ecephys_data_read.cpp example_read_finish_recording_snippet
+ *
+ * \subsection read_design_example_read_posthoc Read data from an existing file
+ *
+ * To read from an existing file we simply need to create the I/O object and the construct the
+ * Container object we want to read.
+ *
+ *  \snippet tests/examples/test_ecephys_data_read.cpp  example_read_only_snippet
+ *
+ */
+
+
diff --git a/docs/pages/userdocs/workflow.dox b/docs/pages/userdocs/workflow.dox
index 4f90846c..855b5b80 100644
--- a/docs/pages/userdocs/workflow.dox
+++ b/docs/pages/userdocs/workflow.dox
@@ -8,7 +8,7 @@
  * For users wanting to integrate NWB with a particular data acquisition software, here
  * we outline the steps for a single recording from file creation to saving.
  *
- * 1. Create the I/O object (e.g,.  \ref AQNWB::HDF5::HDF5IO "HDF5IO") used for
+ * 1. Create the I/O object (e.g,.  \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO") used for
  *    writing data to the file on disk.
  * 2. Create the \ref AQNWB::NWB::RecordingContainers "RecordingContainers" object
  *    used for managing \ref AQNWB::NWB::Container "Container" objects for storing recordings.
@@ -26,11 +26,11 @@
  *
  * \subsection create_io 1. Create the I/O object.
  *
- * First, create an I/O object (e.g., \ref AQNWB::HDF5::HDF5IO "HDF5IO") used for writing
+ * First, create an I/O object (e.g., \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO") used for writing
  * data to the file. AqNWB provides the convenience method, \ref AQNWB::createIO "createIO"
  * to create this object using one of the supported backends. For more fine-grained
  * control of different backend parameters, you can create your own `std::shared_ptr`
- * using any of the derived \ref AQNWB::BaseIO "BaseIO" classes.
+ * using any of the derived \ref AQNWB::IO::BaseIO "BaseIO" classes.
  *
  * \snippet tests/examples/testWorkflowExamples.cpp example_workflow_io_snippet
  *
@@ -61,7 +61,7 @@
  * When adding containers, ownership of the \ref AQNWB::NWB::Container "Container"  is transferred to the
  * \ref AQNWB::NWB::RecordingContainers "RecordingContainers" object, so that we can access it again via
  * its index. New containers will always be appended to the end of the private member
- * ``RecordingContainers.m_containers` object and their index can be tracked
+ * ``RecordingContainers::m_containers`` object and their index can be tracked
  * using the \ref AQNWB::NWB::RecordingContainers::size "RecordingContainers.size" of the input `recordingArrays`.
  *
  * \snippet tests/examples/testWorkflowExamples.cpp example_workflow_datasets_snippet
@@ -72,8 +72,8 @@
  * Then, start the recording process with a call to the ``startRecording`` function of the I/O object.
  *
  *  \note
- * When using \ref AQNWB::HDF5::HDF5IO "HDF5IO" for writing to HDF5, calling
- * \ref AQNWB::HDF5::HDF5IO::startRecording "startRecording" will by default enable
+ * When using \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO" for writing to HDF5, calling
+ * \ref AQNWB::IO::HDF5::HDF5IO::startRecording "startRecording" will by default enable
  * \ref hdf5io_swmr "SWMR mode" to ensure file integrity and support concurrent read.
  * As a result, no additional datasets or groups can be added to the file once a recording
  * has been started unless the file is is closed and reopened.
diff --git a/src/Types.hpp b/src/Types.hpp
index 37bbd8a3..03e7789f 100644
--- a/src/Types.hpp
+++ b/src/Types.hpp
@@ -24,6 +24,17 @@ class Types
     Failure = -1
   };
 
+  /**
+   * @brief Types of object used in the NWB schema
+   */
+  enum StorageObjectType
+  {
+    Group = 0,
+    Dataset = 1,
+    Attribute = 2,
+    Undefined = -1
+  };
+
   /**
    * @brief Alias for the size type used in the project.
    */
diff --git a/src/Utils.hpp b/src/Utils.hpp
index 5c75f98c..8f2681f9 100644
--- a/src/Utils.hpp
+++ b/src/Utils.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <algorithm>
 #include <chrono>
 #include <cmath>
@@ -5,6 +7,7 @@
 #include <ctime>
 #include <iomanip>
 #include <sstream>
+#include <string>
 
 #include <boost/date_time.hpp>
 #include <boost/endian/conversion.hpp>
@@ -12,9 +15,9 @@
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
 
-#include "BaseIO.hpp"
 #include "boost/date_time/c_local_time_adjustor.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 
 namespace AQNWB
 {
@@ -62,11 +65,11 @@ inline std::string getCurrentTime()
  * @brief Factory method to create an IO object.
  * @return A pointer to a BaseIO object
  */
-inline std::shared_ptr<BaseIO> createIO(const std::string& type,
-                                        const std::string& filename)
+inline std::shared_ptr<IO::BaseIO> createIO(const std::string& type,
+                                            const std::string& filename)
 {
   if (type == "HDF5") {
-    return std::make_shared<HDF5::HDF5IO>(filename);
+    return std::make_shared<AQNWB::IO::HDF5::HDF5IO>(filename);
   } else {
     throw std::invalid_argument("Invalid IO type");
   }
@@ -125,4 +128,5 @@ inline std::unique_ptr<int16_t[]> transformToInt16(SizeType numSamples,
 
   return intData;
 }
+
 }  // namespace AQNWB
diff --git a/src/BaseIO.cpp b/src/io/BaseIO.cpp
similarity index 98%
rename from src/BaseIO.cpp
rename to src/io/BaseIO.cpp
index 027d81c6..3d5cc9b6 100644
--- a/src/BaseIO.cpp
+++ b/src/io/BaseIO.cpp
@@ -1,7 +1,8 @@
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 
 #include "Utils.hpp"
 
+using namespace AQNWB::IO;
 using namespace AQNWB;
 
 // BaseDataType
diff --git a/src/BaseIO.hpp b/src/io/BaseIO.hpp
similarity index 88%
rename from src/BaseIO.hpp
rename to src/io/BaseIO.hpp
index 480d96e1..87a6870f 100644
--- a/src/BaseIO.hpp
+++ b/src/io/BaseIO.hpp
@@ -1,16 +1,20 @@
 #pragma once
 
+#include <any>
 #include <cstdint>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include <boost/multi_array.hpp>  // TODO move this and function def to the cpp file
+
 #include "Types.hpp"
 
 #define DEFAULT_STR_SIZE 256
 #define DEFAULT_ARRAY_SIZE 1
 
+using StorageObjectType = AQNWB::Types::StorageObjectType;
 using Status = AQNWB::Types::Status;
 using SizeArray = AQNWB::Types::SizeArray;
 using SizeType = AQNWB::Types::SizeType;
@@ -19,7 +23,7 @@ using SizeType = AQNWB::Types::SizeType;
  * \namespace AQNWB
  * \brief The main namespace for AqNWB
  */
-namespace AQNWB
+namespace AQNWB::IO
 {
 
 class BaseRecordingData;
@@ -79,6 +83,8 @@ class BaseDataType
       SizeType size);  ///< Accessor for string with specified size.
 };
 
+class DataBlockGeneric;
+
 /**
  * @brief The BaseIO class is an abstract base class that defines the interface
  * for input/output (IO) operations on a file.
@@ -117,6 +123,16 @@ class BaseIO
    */
   virtual std::string getFileName() const { return m_filename; }
 
+  /**
+   * @brief  Get the storage type (Group, Dataset, Attribute) of the object at
+   * path
+   *
+   * @param path The path of the object in the file
+   * @return The StorageObjectType. May be Undefined if the object does not
+   * exist.
+   */
+  virtual StorageObjectType getStorageObjectType(std::string path) = 0;
+
   /**
    * @brief Opens the file for writing.
    * @return The status of the file opening operation.
@@ -142,6 +158,41 @@ class BaseIO
    */
   virtual Status flush() = 0;
 
+  /**
+   * @brief Reads a dataset and determines the data type
+   *
+   * We use DataBlockGeneric here, i.e., the subclass must determine the
+   * data type. The user can then convert DataBlockGeneric to the
+   * specific type via DataBlock::fromGeneric.
+   *
+   * @param dataPath The path to the dataset within the file.
+   * @param start The starting indices for the slice (optional).
+   * @param count The number of elements to read for each dimension (optional).
+   * @param stride The stride for each dimension (optional).
+   * @param block The block size for each dimension (optional).
+   *
+   * @return A DataGeneric structure containing the data and shape.
+   */
+  virtual DataBlockGeneric readDataset(
+      const std::string& dataPath,
+      const std::vector<SizeType>& start = {},
+      const std::vector<SizeType>& count = {},
+      const std::vector<SizeType>& stride = {},
+      const std::vector<SizeType>& block = {}) = 0;
+
+  /**
+   * @brief Reads a attribute  and determines the data type
+   *
+   * We use DataBlockGeneric here, i.e., the subclass must determine the
+   * data type. The user can then convert DataBlockGeneric to the
+   * specific type via DataBlock::fromGeneric.
+   *
+   * @param dataPath The path to the attribute within the file.
+   *
+   * @return A DataGeneric structure containing the data and shape.
+   */
+  virtual DataBlockGeneric readAttribute(const std::string& dataPath) = 0;
+
   /**
    * @brief Creates an attribute at a given location in the file.
    * @param type The base data type of the attribute.
@@ -441,4 +492,4 @@ class BaseRecordingData
   SizeType nDimensions;
 };
 
-}  // namespace AQNWB
+}  // namespace AQNWB::IO
diff --git a/src/io/ReadIO.hpp b/src/io/ReadIO.hpp
new file mode 100644
index 00000000..98f89efa
--- /dev/null
+++ b/src/io/ReadIO.hpp
@@ -0,0 +1,368 @@
+#pragma once
+
+#include <any>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <typeindex>
+#include <vector>
+
+#include <boost/multi_array.hpp>  // TODO move this and function def to the cpp file
+
+#include "Types.hpp"
+
+using StorageObjectType = AQNWB::Types::StorageObjectType;
+using SizeType = AQNWB::Types::SizeType;
+
+/*!
+ * \namespace AQNWB
+ * \brief The main namespace for AqNWB
+ */
+namespace AQNWB::IO
+{
+
+/**
+ * @brief Generic structure to hold type-erased data and shape
+ */
+class DataBlockGeneric
+{
+public:
+  /**
+   * @ brief The untyped data values.
+   *
+   * We know this will be a 1-dimensional std::vector of some kind,
+   * so we can cast it via
+   * ``std::any_cast<std::vector<DTYPE>>(genericDataBlock.data)``
+   */
+  std::any data;
+  /**
+   * \brief The 1D vector with the n-dimensional shape of the data.
+   *        Set to empty in case of scalar data.
+   */
+  std::vector<SizeType> shape;
+  /**
+   * \brief Type index of the values stored in the data vector.
+   *
+   * I.e. if data is actually a ``std::vector<float>`` then this should be
+   * set to ``typeid(float)`` and not ``typeid(std::vector<float>)``.
+   * The default value is ``typeid(void)`` to indicate that the data type is
+   * unknown. However, the data type should usually be determined by the
+   * I/O backend when loading data so this should usually be set to the
+   * correct type.
+   */
+  std::type_index typeIndex = typeid(void);
+
+  /**
+   * \brief Default constructor
+   */
+  DataBlockGeneric() = default;
+
+  /**
+   * \brief Parameterized constructor
+   */
+  DataBlockGeneric(const std::any& data,
+                   const std::vector<SizeType>& shape,
+                   const std::type_index& typeIndex)
+      : data(data)
+      , shape(shape)
+      , typeIndex(typeIndex)
+  {
+  }
+};
+
+/**
+ * @brief Structure to hold data and shape for a typed data vector
+ *
+ * @tparam DTYPE The data type of the vector
+ */
+template<typename DTYPE>
+class DataBlock
+{
+public:
+  /**
+   * @ brief The 1D vector with the data values of type DTYPE
+   */
+  std::vector<DTYPE> data;
+  /**
+   * \brief The 1D vector with the n-dimensional shape of the data.
+   *        Set to empty in case of scalar data
+   */
+  std::vector<SizeType> shape;
+  /**
+   * \brief Type index of the values stored in the data vector.
+   *        Here this is fixed to ``typeid(DTYPE)``
+   */
+  const std::type_index typeIndex = typeid(DTYPE);
+
+  /**
+   * Constructor
+   */
+  DataBlock(const std::vector<DTYPE>& data, const std::vector<SizeType>& shape)
+      : data(data)
+      , shape(shape)
+  {
+  }
+
+  /**
+   * \brief Transform the data to a boost multi-dimensional array for convenient
+   * access
+   *
+   * The function uses boost::const_multi_array_ref to avoid copying of the data
+   *
+   * @tparam NDIMS The number of dimensions of the array. Same as shape.size()
+   */
+  template<std::size_t NDIMS>
+  inline boost::const_multi_array_ref<DTYPE, NDIMS> as_multi_array() const
+  {
+    if (shape.size() != NDIMS) {
+      throw std::invalid_argument(
+          "Shape size does not match the number of dimensions.");
+    }
+
+    // Calculate the total number of elements expected
+    SizeType expected_size = 1;
+    for (SizeType dim : shape) {
+      expected_size *= dim;
+    }
+
+    if (data.size() != expected_size) {
+      throw std::invalid_argument("Data size does not match the shape.");
+    }
+
+    // Convert the shape vector to a boost::array
+    boost::array<std::size_t, NDIMS> boost_shape;
+    std::copy(shape.begin(), shape.end(), boost_shape.begin());
+
+    // Construct and return the boost::const_multi_array_ref
+    return boost::const_multi_array_ref<DTYPE, NDIMS>(data.data(), boost_shape);
+  }
+
+  /**
+   * @brief Factory method to create an DataBlock from a DataBlockGeneric.
+   *
+   * The function using std::any_cast to avoid copying the data
+   *
+   * @param genericData The DataBlockGeneric structure containing the data and
+   * shape.
+   *
+   * @return A DataBlock structure containing the data and shape.
+   */
+  inline static DataBlock<DTYPE> fromGeneric(
+      const DataBlockGeneric& genericData)
+  {
+    auto result = DataBlock<DTYPE>(
+        std::any_cast<std::vector<DTYPE>>(genericData.data), genericData.shape);
+    return result;
+  }
+};
+
+/// Helper struct to check if a StorageObjectType is allowed. Used in static
+/// assert.
+template<StorageObjectType T>
+struct isAllowedStorageObjectType : std::false_type
+{
+};
+
+/// Helper struct to check if a StorageObjectType is allowed. Used in static
+/// assert.
+template<>
+struct isAllowedStorageObjectType<StorageObjectType::Dataset> : std::true_type
+{
+};
+
+/// Helper struct to check if a StorageObjectType is allowed. Used in static
+/// assert.
+template<>
+struct isAllowedStorageObjectType<StorageObjectType::Attribute> : std::true_type
+{
+};
+
+/**
+ * @brief Class for wrapping data objects (datasets or attributes) for reading
+ * data from a file
+ *
+ * @tparam OTYPE The type of object being wrapped defined via \ref
+ * AQNWB::Types::StorageObjectType
+ * @tparam VTYPE The data type of the values stored in the data object
+ */
+template<StorageObjectType OTYPE, typename VTYPE = std::any>
+class ReadDataWrapper
+{
+  // Embedded traits for compile time checking of allowed OTYPE for the class
+  // and methods
+private:
+  /**
+   * Embedded Trait to Check the OTYPE Enum Value at compile time to
+   * SFINAE (Substitution Failure Is Not An Error) approach to disable
+   * select functions for attributes, to not support slicing.
+   */
+  template<StorageObjectType U>
+  struct isDataset
+      : std::integral_constant<bool, (U == StorageObjectType::Dataset)>
+  {
+  };
+
+  /**
+   *  Static assert to enforce the restriction that ReadDataWrapper can only be
+   *  instantiated for OTYPE of StorageObjectType::Dataset and
+   *  StorageObjectType::Attribute but not for other types, e.g., Group or
+   * Undefined.
+   */
+  static_assert(isAllowedStorageObjectType<OTYPE>::value,
+                "StorageObjectType not allowed for ReadDataWrapper");
+
+  // Actual definition of the class
+public:
+  /**
+   * @brief Default constructor.
+   *
+   * @param io The IO object to use for reading
+   * @param dataPath The path to the attribute or dataset to read
+   */
+  ReadDataWrapper(const std::shared_ptr<IO::BaseIO> io,
+                  const std::string& dataPath)
+      : io(io)
+      , dataPath(dataPath)
+  {
+  }
+
+  /**
+   * @brief Function to return the \ref AQNWB::Types::StorageObjectType OTYPE of
+   * the instance
+   */
+  inline StorageObjectType getStorageObjectType() const { return OTYPE; }
+
+  /**
+   * @brief Deleted copy constructor to prevent construction-copying.
+   */
+  ReadDataWrapper(const ReadDataWrapper&) = delete;
+
+  /**
+   * @brief Deleted copy assignment operator to prevent copying.
+   */
+  ReadDataWrapper& operator=(const ReadDataWrapper&) = delete;
+
+  /**
+   * @brief Destructor.
+   */
+  virtual ~ReadDataWrapper() {}
+
+  /**
+   * @brief Reads a dataset and determines the data type.
+   *
+   * This functions calls the overloaded valuesGeneric({}, {}, {}, {}) variant
+   *
+   * @return An DataBlockGeneric structure containing the data and shape.
+   */
+  inline DataBlockGeneric valuesGeneric() const
+  {
+    switch (OTYPE) {
+      case StorageObjectType::Dataset: {
+        return this->io->readDataset(this->dataPath);
+      }
+      case StorageObjectType::Attribute: {
+        return this->io->readAttribute(this->dataPath);
+      }
+      default: {
+        throw std::runtime_error("Unsupported StorageObjectType");
+      }
+    }
+  }
+
+  /**
+   * @brief Reads a dataset and determines the data type.
+   *
+   * We do not support slicing for attributes, so this function is disabled for
+   * attributes. For attributes we should only use the valuesGeneric() method
+   * without arguments.
+   *
+   * @param start The starting indices for the slice (required).
+   * @param count The number of elements to read for each dimension (optional).
+   * @param stride The stride for each dimension (optional).
+   * @param block The block size for each dimension (optional).
+   *
+   * @return An DataBlockGeneric structure containing the data and shape.
+   */
+  template<StorageObjectType U = OTYPE,
+           typename std::enable_if<isDataset<U>::value, int>::type = 0>
+  inline DataBlockGeneric valuesGeneric(
+      const std::vector<SizeType>& start,
+      const std::vector<SizeType>& count = {},
+      const std::vector<SizeType>& stride = {},
+      const std::vector<SizeType>& block = {}) const
+  {
+    // The function is only enabled for datasets so we don't need to check
+    // for attributes here.
+    return this->io->readDataset(this->dataPath, start, count, stride, block);
+  }
+
+  /**
+   * @brief Reads an attribute with a specified data type.
+   *
+   * This convenience function uses valuesGeneric to read the data and then
+   * convert the DataBlockGeneric to a specific DataBlock
+   *
+   * @tparam T the value type to use. By default this is set to the VTYPE
+   *           of the object but is added here to allow the user to
+   *           request a different type if approbriate, e.g., if the
+   *           object uses VTYPE=std::any and the user knows the type
+   *           VTYPE=float
+   *
+   * @return A DataBlock structure containing the data and shape.
+   */
+  template<typename T = VTYPE>
+  inline DataBlock<VTYPE> values() const
+  {
+    return DataBlock<T>::fromGeneric(this->valuesGeneric());
+  }
+
+  /**
+   * @brief Reads an dataset with a specified data type.
+   *
+   * This convenience function uses valuesGeneric to read the data and then
+   * convert the DataBlockGeneric to a specific DataBlock/
+   *
+   * We do not support slicing for attributes, so this function is disabled for
+   * attributes. For attributes we should only use the valuesGeneric() method
+   * without arguments.
+   *
+   * @tparam T the value type to use. By default this is set to the VTYPE
+   *           of the object but is added here to allow the user to
+   *           request a different type if approbriate, e.g., if the
+   *           object uses VTYPE=std::any and the user knows the type
+   *           VTYPE=float
+   *
+   * @param start The starting indices for the slice (optional).
+   * @param count The number of elements to read for each dimension (optional).
+   * @param stride The stride for each dimension (optional).
+   * @param block The block size for each dimension (optional).
+   *
+   * @return A DataBlock structure containing the data and shape.
+   */
+  template<typename T = VTYPE,
+           StorageObjectType U = OTYPE,
+           typename std::enable_if<isDataset<U>::value, int>::type = 0>
+  inline DataBlock<VTYPE> values(const std::vector<SizeType>& start,
+                                 const std::vector<SizeType>& count = {},
+                                 const std::vector<SizeType>& stride = {},
+                                 const std::vector<SizeType>& block = {}) const
+  {
+    // The function is only enabled for datasets so we don't need to check
+    // for attributes here.
+    return DataBlock<VTYPE>::fromGeneric(
+        this->valuesGeneric(start, count, stride, block));
+  }
+
+protected:
+  /**
+   * @brief Pointer to the I/O object to use for reading.
+   */
+  const std::shared_ptr<IO::BaseIO> io;  // BaseIO* io;
+  /**
+   * @brief Path to the dataset or attribute to read
+   */
+  std::string dataPath;
+};
+
+}  // namespace AQNWB::IO
diff --git a/src/hdf5/HDF5IO.cpp b/src/io/hdf5/HDF5IO.cpp
similarity index 55%
rename from src/hdf5/HDF5IO.cpp
rename to src/io/hdf5/HDF5IO.cpp
index 9529f246..119bc66b 100644
--- a/src/hdf5/HDF5IO.cpp
+++ b/src/io/hdf5/HDF5IO.cpp
@@ -4,15 +4,16 @@
 #include <memory>
 #include <vector>
 
-#include "hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 
 #include <H5Cpp.h>
 #include <H5Fpublic.h>
 
 #include "Utils.hpp"
+#include "io/hdf5/HDF5RecordingData.hpp"
 
 using namespace H5;
-using namespace AQNWB::HDF5;
+using namespace AQNWB::IO::HDF5;
 
 // HDF5IO
 HDF5IO::HDF5IO(const std::string& filename, const bool disableSWMRMode)
@@ -82,7 +83,305 @@ Status HDF5IO::flush()
   return checkStatus(status);
 }
 
-Status HDF5IO::createAttribute(const BaseDataType& type,
+std::unique_ptr<H5::Attribute> HDF5IO::getAttribute(const std::string& path)
+{
+  // Split the path to get the parent object and the attribute name
+  size_t pos = path.find_last_of('/');
+  if (pos == std::string::npos) {
+    return nullptr;
+  }
+
+  std::string parentPath = path.substr(0, pos);
+  std::string attrName = path.substr(pos + 1);
+
+  try {
+    // Try to open the parent object as a group
+    H5::Group parentGroup = m_file->openGroup(parentPath);
+    return std::make_unique<H5::Attribute>(parentGroup.openAttribute(attrName));
+  } catch (const H5::Exception& e) {
+    // If it's not a group, try to open it as a dataset
+    try {
+      H5::DataSet parentDataset = m_file->openDataSet(parentPath);
+      return std::make_unique<H5::Attribute>(
+          parentDataset.openAttribute(attrName));
+    } catch (const H5::Exception& e) {
+      // Handle HDF5 exceptions
+      return nullptr;
+    }
+  }
+}
+
+StorageObjectType HDF5IO::getStorageObjectType(std::string path)
+{
+  try {
+    H5O_type_t objectType = getH5ObjectType(path);
+
+    switch (objectType) {
+      case H5O_TYPE_GROUP:
+        return StorageObjectType::Group;
+      case H5O_TYPE_DATASET:
+        return StorageObjectType::Dataset;
+      case H5O_TYPE_NAMED_DATATYPE:
+        // Handle named datatype if needed
+        return StorageObjectType::Undefined;
+      default:
+        // Check if the object is an attribute
+        if (auto attr = getAttribute(path)) {
+          return StorageObjectType::Attribute;
+        }
+        return StorageObjectType::Undefined;
+    }
+  } catch (const H5::Exception& e) {
+    // Handle HDF5 exceptions
+    std::cerr << "HDF5 error: " << e.getDetailMsg() << std::endl;
+    return StorageObjectType::Undefined;
+  }
+}
+
+template<typename T, typename HDF5TYPE>
+std::vector<T> HDF5IO::readDataHelper(const HDF5TYPE& dataSource,
+                                      size_t numElements,
+                                      const H5::DataSpace& memspace,
+                                      const H5::DataSpace& dataspace)
+{
+  std::vector<T> data(numElements);
+  if (const H5::DataSet* dataset =
+          dynamic_cast<const H5::DataSet*>(&dataSource))
+  {
+    H5::DataType type = dataset->getDataType();
+    dataset->read(data.data(), type, memspace, dataspace);
+  } else if (const H5::Attribute* attribute =
+                 dynamic_cast<const H5::Attribute*>(&dataSource))
+  {
+    H5::DataType type = attribute->getDataType();
+    attribute->read(type, data.data());
+  } else {
+    throw std::runtime_error("Unsupported data source type");
+  }
+
+  return data;
+}
+
+template<typename T, typename HDF5TYPE>
+std::vector<T> HDF5IO::readDataHelper(const HDF5TYPE& dataSource,
+                                      size_t numElements)
+{
+  return this->readDataHelper<T>(
+      dataSource, numElements, H5::DataSpace(), H5::DataSpace());
+}
+
+template<typename HDF5TYPE>
+std::vector<std::string> HDF5IO::readStringDataHelper(
+    const HDF5TYPE& dataSource,
+    size_t numElements,
+    const H5::DataSpace& memspace,
+    const H5::DataSpace& dataspace)
+{
+  std::vector<std::string> data(numElements);
+  if (const H5::DataSet* dataset =
+          dynamic_cast<const H5::DataSet*>(&dataSource))
+  {
+    H5::StrType strType(H5::PredType::C_S1);
+    dataset->read(data.data(), strType, memspace, dataspace);
+  } else if (const H5::Attribute* attribute =
+                 dynamic_cast<const H5::Attribute*>(&dataSource))
+  {
+    H5::StrType strType(H5::PredType::C_S1);
+    attribute->read(strType, data.data());
+  } else {
+    throw std::runtime_error("Unsupported data source type");
+  }
+  return data;
+}
+
+template<typename HDF5TYPE>
+std::vector<std::string> HDF5IO::readStringDataHelper(
+    const HDF5TYPE& dataSource, size_t numElements)
+{
+  return this->readStringDataHelper(
+      dataSource, numElements, H5::DataSpace(), H5::DataSpace());
+}
+
+AQNWB::IO::DataBlockGeneric HDF5IO::readAttribute(const std::string& dataPath)
+{
+  // create the return value to fill
+  IO::DataBlockGeneric result;
+  // Read the attribute
+  auto attributePtr = this->getAttribute(dataPath);
+  // Make sure dataPath points to an attribute
+  assert(attributePtr != nullptr);
+  H5::Attribute& attribute = *attributePtr;
+  H5::DataType dataType = attribute.getDataType();
+
+  // Determine the shape of the attribute
+  H5::DataSpace dataspace = attribute.getSpace();
+  SizeType rank = dataspace.getSimpleExtentNdims();
+  if (rank == 0) {
+    // Scalar attribute
+    result.shape.clear();
+  } else {
+    std::vector<hsize_t> tempShape(rank);
+    dataspace.getSimpleExtentDims(tempShape.data(), nullptr);
+    result.shape.clear();
+    result.shape.reserve(rank);
+    for (const auto& v : tempShape) {
+      result.shape.push_back(v);
+    }
+  }
+
+  // Determine the size of the attribute from the shape
+  // For some reason using "size_t numElements = attribute.getStorageSize();"
+  // seems to not always give the expected size (but may be larger), so
+  // we calculate the number of elements from the shape instead
+  size_t numElements = 1;  // Scalar (default)
+  if (result.shape.size() > 0)  // N-dimensional array
+  {
+    for (const auto v : result.shape) {
+      numElements *= v;
+    }
+  }
+
+  // Read the attribute into a vector of the appropriate type
+  if (dataType == H5::PredType::C_S1) {
+    result.data = readStringDataHelper(attribute, numElements);
+    result.typeIndex = typeid(std::string);
+  } else if (dataType == H5::PredType::NATIVE_DOUBLE) {
+    result.data = readDataHelper<double>(attribute, numElements);
+    result.typeIndex = typeid(double);
+  } else if (dataType == H5::PredType::NATIVE_FLOAT) {
+    result.data = readDataHelper<float>(attribute, numElements);
+    result.typeIndex = typeid(float);
+  } else if (dataType == H5::PredType::NATIVE_INT) {
+    result.data = readDataHelper<int>(attribute, numElements);
+    result.typeIndex = typeid(int);
+  } else if (dataType == H5::PredType::NATIVE_UINT) {
+    result.data = readDataHelper<unsigned int>(attribute, numElements);
+    result.typeIndex = typeid(unsigned int);
+  } else if (dataType == H5::PredType::NATIVE_LONG) {
+    result.data = readDataHelper<long>(attribute, numElements);
+    result.typeIndex = typeid(long);
+  } else if (dataType == H5::PredType::NATIVE_ULONG) {
+    result.data = readDataHelper<unsigned long>(attribute, numElements);
+    result.typeIndex = typeid(unsigned long);
+  } else if (dataType == H5::PredType::NATIVE_LLONG) {
+    result.data = readDataHelper<long long>(attribute, numElements);
+    result.typeIndex = typeid(long long);
+  } else if (dataType == H5::PredType::NATIVE_ULLONG) {
+    result.data = readDataHelper<unsigned long long>(attribute, numElements);
+    result.typeIndex = typeid(unsigned long long);
+  } else {
+    throw std::runtime_error("Unsupported data type");
+  }
+
+  return result;
+}
+
+AQNWB::IO::DataBlockGeneric HDF5IO::readDataset(
+    const std::string& dataPath,
+    const std::vector<SizeType>& start,
+    const std::vector<SizeType>& count,
+    const std::vector<SizeType>& stride,
+    const std::vector<SizeType>& block)
+{
+  // Check that the dataset exists
+  assert(H5Lexists(m_file->getId(), dataPath.c_str(), H5P_DEFAULT) > 0);
+  // create the return value to fill
+  IO::DataBlockGeneric result;
+
+  // Create new vectors of type hsize_t for stride and block because
+  // HDF5 needs hsize_t and we use SizeType in AqNWB instead
+  std::vector<hsize_t> stride_hsize(stride.size());
+  std::vector<hsize_t> block_hsize(block.size());
+  // Copy elements from the original vectors to the new vectors
+  std::copy(stride.begin(), stride.end(), stride_hsize.begin());
+  std::copy(block.begin(), block.end(), block_hsize.begin());
+
+  // Read the dataset
+  H5::DataSet dataset = m_file->openDataSet(dataPath);
+
+  // Get the dataspace of the dataset
+  H5::DataSpace dataspace = dataset.getSpace();
+
+  // Get the number of dimensions and their sizes
+  int rank = dataspace.getSimpleExtentNdims();
+  hsize_t dims[rank];
+  dataspace.getSimpleExtentDims(dims, nullptr);
+
+  // Store the shape information
+  result.shape.assign(dims, dims + rank);
+
+  // Calculate the total number of elements
+  size_t numElements = 1;
+  for (int i = 0; i < rank; ++i) {
+    numElements *= dims[i];
+  }
+
+  // Create a memory dataspace for the slice
+  H5::DataSpace memspace;
+  if (!start.empty() && !count.empty()) {
+    hsize_t offset[rank];
+    hsize_t block_count[rank];
+    for (int i = 0; i < rank; ++i) {
+      offset[i] = start[i];
+      block_count[i] = count[i];
+    }
+    dataspace.selectHyperslab(
+        H5S_SELECT_SET,
+        block_count,
+        offset,
+        stride_hsize.empty() ? nullptr : stride_hsize.data(),
+        block_hsize.empty() ? nullptr : block_hsize.data());
+    memspace = H5::DataSpace(rank, block_count);
+  } else {
+    memspace = H5::DataSpace(dataspace);
+  }
+
+  // Read the dataset into a vector of the appropriate type
+  H5::DataType dataType = dataset.getDataType();
+  if (dataType == H5::PredType::C_S1) {
+    result.data =
+        readStringDataHelper(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(std::string);
+  } else if (dataType == H5::PredType::NATIVE_DOUBLE) {
+    result.data =
+        readDataHelper<double>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(double);
+  } else if (dataType == H5::PredType::NATIVE_FLOAT) {
+    result.data =
+        readDataHelper<float>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(float);
+  } else if (dataType == H5::PredType::NATIVE_INT) {
+    result.data =
+        readDataHelper<int>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(int);
+  } else if (dataType == H5::PredType::NATIVE_UINT) {
+    result.data =
+        readDataHelper<unsigned int>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(unsigned int);
+  } else if (dataType == H5::PredType::NATIVE_LONG) {
+    result.data =
+        readDataHelper<long>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(long);
+  } else if (dataType == H5::PredType::NATIVE_ULONG) {
+    result.data = readDataHelper<unsigned long>(
+        dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(unsigned long);
+  } else if (dataType == H5::PredType::NATIVE_LLONG) {
+    result.data =
+        readDataHelper<long long>(dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(long long);
+  } else if (dataType == H5::PredType::NATIVE_ULLONG) {
+    result.data = readDataHelper<unsigned long long>(
+        dataset, numElements, memspace, dataspace);
+    result.typeIndex = typeid(unsigned long long);
+  } else {
+    throw std::runtime_error("Unsupported data type");
+  }
+  // return the result
+  return result;
+}
+
+Status HDF5IO::createAttribute(const IO::BaseDataType& type,
                                const void* data,
                                const std::string& path,
                                const std::string& name,
@@ -99,7 +398,7 @@ Status HDF5IO::createAttribute(const BaseDataType& type,
     return Status::Failure;
 
   // open the group or dataset
-  H5O_type_t objectType = getObjectType(path);
+  H5O_type_t objectType = getH5ObjectType(path);
   switch (objectType) {
     case H5O_TYPE_GROUP:
       gloc = m_file->openGroup(path);
@@ -177,7 +476,7 @@ Status HDF5IO::createAttribute(const std::vector<const char*>& data,
   H5type.setSize(H5T_VARIABLE);
 
   // open the group or dataset
-  H5O_type_t objectType = getObjectType(path);
+  H5O_type_t objectType = getH5ObjectType(path);
   switch (objectType) {
     case H5O_TYPE_GROUP:
       gloc = m_file->openGroup(path);
@@ -231,7 +530,7 @@ Status HDF5IO::createReferenceAttribute(const std::string& referencePath,
     return Status::Failure;
 
   // open the group or dataset
-  H5O_type_t objectType = getObjectType(path);
+  H5O_type_t objectType = getH5ObjectType(path);
   switch (objectType) {
     case H5O_TYPE_GROUP:
       gloc = m_file->openGroup(path);
@@ -356,7 +655,7 @@ Status HDF5IO::createStringDataSet(const std::string& path,
     return Status::Failure;
 
   std::unique_ptr<H5::DataSet> dataset;
-  DataType H5type = getH5Type(BaseDataType::STR(value.length()));
+  DataType H5type = getH5Type(IO::BaseDataType::STR(value.length()));
   DataSpace dSpace(H5S_SCALAR);
 
   dataset = std::make_unique<H5::DataSet>(
@@ -378,11 +677,11 @@ Status HDF5IO::createStringDataSet(const std::string& path,
     cStrs.push_back(str.c_str());
   }
 
-  std::unique_ptr<BaseRecordingData> dataset;
-  dataset = std::unique_ptr<BaseRecordingData>(createArrayDataSet(
-      BaseDataType::V_STR, SizeArray {values.size()}, SizeArray {1}, path));
+  std::unique_ptr<IO::BaseRecordingData> dataset;
+  dataset = std::unique_ptr<IO::BaseRecordingData>(createArrayDataSet(
+      IO::BaseDataType::V_STR, SizeArray {values.size()}, SizeArray {1}, path));
   dataset->writeDataBlock(
-      std::vector<SizeType>(1, 1), BaseDataType::V_STR, cStrs.data());
+      std::vector<SizeType>(1, 1), IO::BaseDataType::V_STR, cStrs.data());
 
   return Status::Success;
 }
@@ -439,7 +738,7 @@ bool HDF5IO::objectExists(const std::string& path)
   }
 }
 
-std::unique_ptr<AQNWB::BaseRecordingData> HDF5IO::getDataSet(
+std::unique_ptr<AQNWB::IO::BaseRecordingData> HDF5IO::getDataSet(
     const std::string& path)
 {
   std::unique_ptr<DataSet> data;
@@ -462,8 +761,8 @@ std::unique_ptr<AQNWB::BaseRecordingData> HDF5IO::getDataSet(
   }
 }
 
-std::unique_ptr<AQNWB::BaseRecordingData> HDF5IO::createArrayDataSet(
-    const BaseDataType& type,
+std::unique_ptr<AQNWB::IO::BaseRecordingData> HDF5IO::createArrayDataSet(
+    const IO::BaseDataType& type,
     const SizeArray& size,
     const SizeArray& chunking,
     const std::string& path)
@@ -506,7 +805,7 @@ std::unique_ptr<AQNWB::BaseRecordingData> HDF5IO::createArrayDataSet(
   return std::make_unique<HDF5RecordingData>(std::move(data));
 }
 
-H5O_type_t HDF5IO::getObjectType(const std::string& path)
+H5O_type_t HDF5IO::getH5ObjectType(const std::string& path)
 {
 #if H5_VERSION_GE(1, 12, 0)
   // get whether path is a dataset or group
@@ -523,45 +822,45 @@ H5O_type_t HDF5IO::getObjectType(const std::string& path)
   return objectType;
 }
 
-H5::DataType HDF5IO::getNativeType(BaseDataType type)
+H5::DataType HDF5IO::getNativeType(IO::BaseDataType type)
 {
   H5::DataType baseType;
 
   switch (type.type) {
-    case BaseDataType::Type::T_I8:
+    case IO::BaseDataType::Type::T_I8:
       baseType = PredType::NATIVE_INT8;
       break;
-    case BaseDataType::Type::T_I16:
+    case IO::BaseDataType::Type::T_I16:
       baseType = PredType::NATIVE_INT16;
       break;
-    case BaseDataType::Type::T_I32:
+    case IO::BaseDataType::Type::T_I32:
       baseType = PredType::NATIVE_INT32;
       break;
-    case BaseDataType::Type::T_I64:
+    case IO::BaseDataType::Type::T_I64:
       baseType = PredType::NATIVE_INT64;
       break;
-    case BaseDataType::Type::T_U8:
+    case IO::BaseDataType::Type::T_U8:
       baseType = PredType::NATIVE_UINT8;
       break;
-    case BaseDataType::Type::T_U16:
+    case IO::BaseDataType::Type::T_U16:
       baseType = PredType::NATIVE_UINT16;
       break;
-    case BaseDataType::Type::T_U32:
+    case IO::BaseDataType::Type::T_U32:
       baseType = PredType::NATIVE_UINT32;
       break;
-    case BaseDataType::Type::T_U64:
+    case IO::BaseDataType::Type::T_U64:
       baseType = PredType::NATIVE_UINT64;
       break;
-    case BaseDataType::Type::T_F32:
+    case IO::BaseDataType::Type::T_F32:
       baseType = PredType::NATIVE_FLOAT;
       break;
-    case BaseDataType::Type::T_F64:
+    case IO::BaseDataType::Type::T_F64:
       baseType = PredType::NATIVE_DOUBLE;
       break;
-    case BaseDataType::Type::T_STR:
+    case IO::BaseDataType::Type::T_STR:
       return StrType(PredType::C_S1, type.typeSize);
       break;
-    case BaseDataType::Type::V_STR:
+    case IO::BaseDataType::Type::V_STR:
       return StrType(PredType::C_S1, H5T_VARIABLE);
       break;
     default:
@@ -574,7 +873,7 @@ H5::DataType HDF5IO::getNativeType(BaseDataType type)
     return baseType;
 }
 
-H5::DataType HDF5IO::getH5Type(BaseDataType type)
+H5::DataType HDF5IO::getH5Type(IO::BaseDataType type)
 {
   H5::DataType baseType;
 
@@ -624,102 +923,3 @@ H5::DataType HDF5IO::getH5Type(BaseDataType type)
   } else
     return baseType;
 }
-
-// HDF5RecordingData
-HDF5RecordingData::HDF5RecordingData(std::unique_ptr<H5::DataSet> data)
-{
-  DataSpace dSpace = data->getSpace();
-  DSetCreatPropList prop = data->getCreatePlist();
-
-  int nDimensions = dSpace.getSimpleExtentNdims();
-  std::vector<hsize_t> dims(nDimensions), chunk(nDimensions);
-
-  nDimensions = dSpace.getSimpleExtentDims(
-      dims.data());  // TODO -redefine here or use original?
-  prop.getChunk(static_cast<int>(nDimensions), chunk.data());
-
-  this->size = std::vector<SizeType>(nDimensions);
-  for (int i = 0; i < nDimensions; ++i) {
-    this->size[i] = dims[i];
-  }
-  this->nDimensions = nDimensions;
-  this->position = std::vector<SizeType>(
-      nDimensions, 0);  // Initialize position with 0 for each dimension
-  m_dataset = std::make_unique<H5::DataSet>(*data);
-}
-
-// HDF5RecordingData
-
-HDF5RecordingData::~HDF5RecordingData()
-{
-  // Safety
-  m_dataset->flush(H5F_SCOPE_GLOBAL);
-}
-
-Status HDF5RecordingData::writeDataBlock(
-    const std::vector<SizeType>& dataShape,
-    const std::vector<SizeType>& positionOffset,
-    const BaseDataType& type,
-    const void* data)
-{
-  try {
-    // check dataShape and positionOffset inputs match the dimensions of the
-    // dataset
-    if (dataShape.size() != nDimensions || positionOffset.size() != nDimensions)
-    {
-      return Status::Failure;
-    }
-
-    // Ensure that we have enough space to accommodate new data
-    std::vector<hsize_t> dSetDims(nDimensions), offset(nDimensions);
-    for (int i = 0; i < nDimensions; ++i) {
-      offset[i] = static_cast<hsize_t>(positionOffset[i]);
-
-      if (dataShape[i] + offset[i] > size[i])  // TODO - do I need offset here
-        dSetDims[i] = dataShape[i] + offset[i];
-      else
-        dSetDims[i] = size[i];
-    }
-
-    // Adjust dataset dimensions if necessary
-    m_dataset->extend(dSetDims.data());
-
-    // Set size to new size based on updated dimensionality
-    DataSpace fSpace = m_dataset->getSpace();
-    fSpace.getSimpleExtentDims(dSetDims.data());
-    for (int i = 0; i < nDimensions; ++i) {
-      size[i] = dSetDims[i];
-    }
-
-    // Create memory space with the shape of the data
-    // DataSpace mSpace(dimension, dSetDim.data());
-    std::vector<hsize_t> dataDims(nDimensions);
-    for (int i = 0; i < nDimensions; ++i) {
-      if (dataShape[i] == 0) {
-        dataDims[i] = 1;
-      } else {
-        dataDims[i] = static_cast<hsize_t>(dataShape[i]);
-      }
-    }
-    DataSpace mSpace(static_cast<int>(nDimensions), dataDims.data());
-
-    // Select hyperslab in the file space
-    fSpace.selectHyperslab(H5S_SELECT_SET, dataDims.data(), offset.data());
-
-    // Write the data
-    DataType nativeType = HDF5IO::getNativeType(type);
-    m_dataset->write(data, nativeType, mSpace, fSpace);
-
-    // Update position for simple extension
-    for (int i = 0; i < dataShape.size(); ++i) {
-      position[i] += dataShape[i];
-    }
-  } catch (DataSetIException error) {
-    error.printErrorStack();
-  } catch (DataSpaceIException error) {
-    error.printErrorStack();
-  } catch (FileIException error) {
-    error.printErrorStack();
-  }
-  return Status::Success;
-}
diff --git a/src/hdf5/HDF5IO.hpp b/src/io/hdf5/HDF5IO.hpp
similarity index 59%
rename from src/hdf5/HDF5IO.hpp
rename to src/io/hdf5/HDF5IO.hpp
index d9f3c851..7d69a220 100644
--- a/src/hdf5/HDF5IO.hpp
+++ b/src/io/hdf5/HDF5IO.hpp
@@ -6,24 +6,30 @@
 
 #include <H5Opublic.h>
 
-#include "BaseIO.hpp"
 #include "Types.hpp"
+#include "io/BaseIO.hpp"
+#include "io/ReadIO.hpp"
 
 namespace H5
 {
 class DataSet;
+class Attribute;
 class H5File;
 class DataType;
 class Exception;
+class CommonFG;
+class PredType;
+class DataSpace;
 }  // namespace H5
 
 /*!
  * \namespace AQNWB::HDF5
  * \brief Namespace for all components of the HDF5 I/O backend
  */
-namespace AQNWB::HDF5
+namespace AQNWB::IO::HDF5
 {
-class HDF5RecordingData;  // declare here because gets used in HDF5IO class
+
+class HDF5RecordingData;  // forward declaration
 
 /**
  * @brief The HDF5IO class provides an interface for reading and writing data to
@@ -73,6 +79,52 @@ class HDF5IO : public BaseIO
    */
   Status flush() override;
 
+  /**
+   * @brief  Get the storage type (Group, Dataset, Attribute) of the object at
+   * path
+   *
+   * @param path The path of the object in the file
+   * @return The StorageObjectType. May be Undefined if the object does not
+   * exist.
+   */
+  StorageObjectType getStorageObjectType(std::string path) override;
+
+  /**
+   * @brief Reads a dataset or attribute and determines the data type.
+   *
+   * @param dataPath The path to the dataset or attribute within the file.
+   * @param start The starting indices for the slice (optional).
+   * @param count The number of elements to read for each dimension (optional).
+   * @param stride The stride for each dimension (optional).
+   * @param block The block size for each dimension (optional).
+   *
+   * @exception May raise various H5 exceptions if read fails
+   *
+   * @return A DataGeneric structure containing the data and shape.
+   */
+  AQNWB::IO::DataBlockGeneric readDataset(
+      const std::string& dataPath,
+      const std::vector<SizeType>& start = {},
+      const std::vector<SizeType>& count = {},
+      const std::vector<SizeType>& stride = {},
+      const std::vector<SizeType>& block = {}) override;
+
+  /**
+   * @brief Reads a attribute  and determines the data type
+   *
+   * We use IO::DataBlockGeneric here, i.e., the subclass must determine the
+   * data type. The user can then convert IO::DataBlockGeneric to the
+   * specific type via DataBlock::fromGeneric.
+   *
+   * @param dataPath The path to the attribute within the file.
+   *
+   * @exception May raise various H5 exceptions if read fails
+   *
+   * @return A DataGeneric structure containing the data and shape.
+   */
+  AQNWB::IO::DataBlockGeneric readAttribute(
+      const std::string& dataPath) override;
+
   /**
    * @brief Creates an attribute at a given location in the file.
    * @param type The base data type of the attribute.
@@ -82,7 +134,7 @@ class HDF5IO : public BaseIO
    * @param size The size of the attribute (default is 1).
    * @return The status of the attribute creation operation.
    */
-  Status createAttribute(const BaseDataType& type,
+  Status createAttribute(const IO::BaseDataType& type,
                          const void* data,
                          const std::string& path,
                          const std::string& name,
@@ -209,8 +261,8 @@ class HDF5IO : public BaseIO
    * @param path The location in the file of the new dataset.
    * @return A pointer to the created dataset.
    */
-  std::unique_ptr<BaseRecordingData> createArrayDataSet(
-      const BaseDataType& type,
+  std::unique_ptr<IO::BaseRecordingData> createArrayDataSet(
+      const IO::BaseDataType& type,
       const SizeArray& size,
       const SizeArray& chunking,
       const std::string& path) override;
@@ -220,7 +272,7 @@ class HDF5IO : public BaseIO
    * @param path The location in the file of the dataset.
    * @return A pointer to the dataset.
    */
-  std::unique_ptr<BaseRecordingData> getDataSet(
+  std::unique_ptr<IO::BaseRecordingData> getDataSet(
       const std::string& path) override;
 
   /**
@@ -236,21 +288,21 @@ class HDF5IO : public BaseIO
    * @param path The location in the file of the object.
    * @return The type of object at the given path.
    */
-  H5O_type_t getObjectType(const std::string& path);
+  H5O_type_t getH5ObjectType(const std::string& path);
 
   /**
    * @brief Returns the HDF5 native data type for a given base data type.
    * @param type The base data type.
    * @return The HDF5 native data type.
    */
-  static H5::DataType getNativeType(BaseDataType type);
+  static H5::DataType getNativeType(IO::BaseDataType type);
 
   /**
    * @brief Returns the HDF5 data type for a given base data type.
    * @param type The base data type.
    * @return The HDF5 data type.
    */
-  static H5::DataType getH5Type(BaseDataType type);
+  static H5::DataType getH5Type(IO::BaseDataType type);
 
 protected:
   /**
@@ -262,74 +314,97 @@ class HDF5IO : public BaseIO
 
 private:
   /**
-   * @brief the HDF5 file
+   * @brief Reads data from an HDF5 dataset or attribute into a vector of the
+   * appropriate type.
+   *
+   * This is an internal helper function used to simplify the implementation
+   * of the readData method.
+   *
+   * @tparam T The data type of the dataset or attribute.
+   * @tparam HDF5TYPE HDF5 Dataset or Attribute type, usually determined from
+   * dataSource
+   * @param dataSource The HDF5 data source (dataset or attribute).
+   * @param numElements The number of elements to read.
+   * @param memspace The memory dataspace (optional).
+   * @param dataspace The file dataspace (optional).
+   *
+   * @return A vector containing the data.
+   */
+  template<typename T, typename HDF5TYPE>
+  std::vector<T> readDataHelper(const HDF5TYPE& dataSource,
+                                size_t numElements,
+                                const H5::DataSpace& memspace,
+                                const H5::DataSpace& dataspace);
+
+  /**
+   * @brief Reads data from an HDF5 dataset or attribute into a vector of the
+   * appropriate type.
+   *
+   * This is the same as readDataHelper but with default parameters defined for
+   * the memspace and dataspace parameters. We overload the method here, rather
+   * than defining default parameters directly, to avoid having to include
+   * <H5Cpp.h> in the HDF5IO.hpp header file.
+   *
+   * @tparam T The data type of the dataset or attribute.
+   * @tparam HDF5TYPE HDF5 Dataset or Attribute type, usually determined from
+   * dataSource
+   * @param dataSource The HDF5 data source (dataset or attribute).
+   * @param numElements The number of elements to read.
+   *
+   * @return A vector containing the data.
+   */
+  template<typename T, typename HDF5TYPE>
+  std::vector<T> readDataHelper(const HDF5TYPE& dataSource, size_t numElements);
+
+  /**
+   * @brief Reads a variable-length string from an HDF5 dataset or attribute.
+   *
+   * @tparam HDF5TYPE HDF5 Dataset or Attribute type, usually determined from
+   * dataSource
+   * @param dataSource The HDF5 data source (dataset or attribute).
+   * @param numElements The number of elements to read.
+   * @param memspace The memory dataspace (optional).
+   * @param dataspace The file dataspace (optional).
+   *
+   * @return A vector containing the data.
+   */
+  template<typename HDF5TYPE>
+  std::vector<std::string> readStringDataHelper(const HDF5TYPE& dataSource,
+                                                size_t numElements,
+                                                const H5::DataSpace& memspace,
+                                                const H5::DataSpace& dataspace);
+
+  /**
+   * @brief Reads a variable-length string from an HDF5 dataset or attribute.
+   *
+   * This is the same as readStringDataHelper but with default parameters
+   * defined for the memspace and dataspace parameters. We overload the method
+   * here, rather than defining default parameters directly, to avoid having to
+   * include <H5Cpp.h> in the HDF5IO.hpp header file.
+   *
+   * @tparam HDF5TYPE HDF5 Dataset or Attribute type, usually determined from
+   * dataSource
+   * @param dataSource The HDF5 data source (dataset or attribute).
+   * @param numElements The number of elements to read.
+   *
+   * @return A vector containing the data.
+   */
+  template<typename HDF5TYPE>
+  std::vector<std::string> readStringDataHelper(const HDF5TYPE& dataSource,
+                                                size_t numElements);
+
+  std::unique_ptr<H5::Attribute> getAttribute(const std::string& path);
+
+  /**
+   * @brief Unique pointer to the HDF5 file for reading
    */
   std::unique_ptr<H5::H5File> m_file;
+
   /**
-   * @brief When set do not use SWMR mode when opening the HDF5 file
+   * \brief When set true, then do not switch to SWMR mode when starting the
+   * recording
    */
   bool m_disableSWMRMode;
 };
 
-/**
- * @brief Represents an HDF5 Dataset that can be extended indefinitely
-        in blocks.
-*
-* This class provides functionality for reading and writing blocks of data
-* to an HDF5 dataset.
-*/
-class HDF5RecordingData : public BaseRecordingData
-{
-public:
-  /**
-   * @brief Constructs an HDF5RecordingData object.
-   * @param data A pointer to the HDF5 dataset.
-   */
-  HDF5RecordingData(std::unique_ptr<H5::DataSet> data);
-
-  /**
-   * @brief Deleted copy constructor to prevent construction-copying.
-   */
-  HDF5RecordingData(const HDF5RecordingData&) = delete;
-
-  /**
-   * @brief Deleted copy assignment operator to prevent copying.
-   */
-  HDF5RecordingData& operator=(const HDF5RecordingData&) = delete;
-
-  /**
-   * @brief Destroys the HDF5RecordingData object.
-   */
-  ~HDF5RecordingData();
-
-  /**
-   * @brief Writes a block of data to the HDF5 dataset.
-   * @param dataShape The size of the data block.
-   * @param positionOffset The position of the data block to write to.
-   * @param type The data type of the elements in the data block.
-   * @param data A pointer to the data block.
-   * @return The status of the write operation.
-   */
-  Status writeDataBlock(const std::vector<SizeType>& dataShape,
-                        const std::vector<SizeType>& positionOffset,
-                        const BaseDataType& type,
-                        const void* data);
-
-  /**
-   * @brief Gets a const pointer to the HDF5 dataset.
-   * @return A const pointer to the HDF5 dataset.
-   */
-  inline const H5::DataSet* getDataSet() const { return m_dataset.get(); }
-
-private:
-  /**
-   * @brief Return status of HDF5 operations.
-   */
-  Status checkStatus(int status);
-
-  /**
-   * @brief Pointer to an extendable HDF5 dataset
-   */
-  std::unique_ptr<H5::DataSet> m_dataset;
-};
-}  // namespace AQNWB::HDF5
+}  // namespace AQNWB::IO::HDF5
diff --git a/src/io/hdf5/HDF5RecordingData.cpp b/src/io/hdf5/HDF5RecordingData.cpp
new file mode 100644
index 00000000..eabb92cb
--- /dev/null
+++ b/src/io/hdf5/HDF5RecordingData.cpp
@@ -0,0 +1,111 @@
+#include <codecvt>
+#include <filesystem>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include "io/hdf5/HDF5RecordingData.hpp"
+
+#include <H5Cpp.h>
+#include <H5Fpublic.h>
+
+#include "Utils.hpp"
+
+using namespace H5;
+using namespace AQNWB::IO::HDF5;
+
+HDF5RecordingData::HDF5RecordingData(std::unique_ptr<H5::DataSet> data)
+{
+  DataSpace dSpace = data->getSpace();
+  DSetCreatPropList prop = data->getCreatePlist();
+
+  int nDimensions = dSpace.getSimpleExtentNdims();
+  std::vector<hsize_t> dims(nDimensions), chunk(nDimensions);
+
+  nDimensions = dSpace.getSimpleExtentDims(
+      dims.data());  // TODO -redefine here or use original?
+  prop.getChunk(static_cast<int>(nDimensions), chunk.data());
+
+  this->size = std::vector<SizeType>(nDimensions);
+  for (int i = 0; i < nDimensions; ++i) {
+    this->size[i] = dims[i];
+  }
+  this->nDimensions = nDimensions;
+  this->position = std::vector<SizeType>(
+      nDimensions, 0);  // Initialize position with 0 for each dimension
+  m_dataset = std::make_unique<H5::DataSet>(*data);
+}
+
+HDF5RecordingData::~HDF5RecordingData()
+{
+  // Safety
+  m_dataset->flush(H5F_SCOPE_GLOBAL);
+}
+
+Status HDF5RecordingData::writeDataBlock(
+    const std::vector<SizeType>& dataShape,
+    const std::vector<SizeType>& positionOffset,
+    const BaseDataType& type,
+    const void* data)
+{
+  try {
+    // check dataShape and positionOffset inputs match the dimensions of the
+    // dataset
+    if (dataShape.size() != nDimensions || positionOffset.size() != nDimensions)
+    {
+      return Status::Failure;
+    }
+
+    // Ensure that we have enough space to accommodate new data
+    std::vector<hsize_t> dSetDims(nDimensions), offset(nDimensions);
+    for (int i = 0; i < nDimensions; ++i) {
+      offset[i] = static_cast<hsize_t>(positionOffset[i]);
+
+      if (dataShape[i] + offset[i] > size[i])  // TODO - do I need offset here
+        dSetDims[i] = dataShape[i] + offset[i];
+      else
+        dSetDims[i] = size[i];
+    }
+
+    // Adjust dataset dimensions if necessary
+    m_dataset->extend(dSetDims.data());
+
+    // Set size to new size based on updated dimensionality
+    DataSpace fSpace = m_dataset->getSpace();
+    fSpace.getSimpleExtentDims(dSetDims.data());
+    for (int i = 0; i < nDimensions; ++i) {
+      size[i] = dSetDims[i];
+    }
+
+    // Create memory space with the shape of the data
+    // DataSpace mSpace(dimension, dSetDim.data());
+    std::vector<hsize_t> dataDims(nDimensions);
+    for (int i = 0; i < nDimensions; ++i) {
+      if (dataShape[i] == 0) {
+        dataDims[i] = 1;
+      } else {
+        dataDims[i] = static_cast<hsize_t>(dataShape[i]);
+      }
+    }
+    DataSpace mSpace(static_cast<int>(nDimensions), dataDims.data());
+
+    // Select hyperslab in the file space
+    fSpace.selectHyperslab(H5S_SELECT_SET, dataDims.data(), offset.data());
+
+    // Write the data
+    DataType nativeType = HDF5IO::getNativeType(type);
+    m_dataset->write(data, nativeType, mSpace, fSpace);
+
+    // Update position for simple extension
+    for (int i = 0; i < dataShape.size(); ++i) {
+      position[i] += dataShape[i];
+    }
+  } catch (DataSetIException error) {
+    error.printErrorStack();
+  } catch (DataSpaceIException error) {
+    error.printErrorStack();
+  } catch (FileIException error) {
+    error.printErrorStack();
+  }
+  return Status::Success;
+}
diff --git a/src/io/hdf5/HDF5RecordingData.hpp b/src/io/hdf5/HDF5RecordingData.hpp
new file mode 100644
index 00000000..5595255e
--- /dev/null
+++ b/src/io/hdf5/HDF5RecordingData.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "io/BaseIO.hpp"
+
+namespace H5
+{
+class DataSet;
+}  // namespace H5
+
+namespace AQNWB::IO::HDF5
+{
+/**
+ * @brief Represents an HDF5 Dataset that can be extended indefinitely
+ *        in blocks.
+ *
+ * This class provides functionality for reading and writing blocks of data
+ * to an HDF5 dataset.
+ */
+class HDF5RecordingData : public AQNWB::IO::BaseRecordingData
+{
+public:
+  /**
+   * @brief Constructs an HDF5RecordingData object.
+   * @param data A pointer to the HDF5 dataset.
+   */
+  HDF5RecordingData(std::unique_ptr<H5::DataSet> data);
+
+  /**
+   * @brief Deleted copy constructor to prevent construction-copying.
+   */
+  HDF5RecordingData(const HDF5RecordingData&) = delete;
+
+  /**
+   * @brief Deleted copy assignment operator to prevent copying.
+   */
+  HDF5RecordingData& operator=(const HDF5RecordingData&) = delete;
+
+  /**
+   * @brief Destroys the HDF5RecordingData object.
+   */
+  ~HDF5RecordingData();
+
+  /**
+   * @brief Writes a block of data to the HDF5 dataset.
+   * @param dataShape The size of the data block.
+   * @param positionOffset The position of the data block to write to.
+   * @param type The data type of the elements in the data block.
+   * @param data A pointer to the data block.
+   * @return The status of the write operation.
+   */
+  Status writeDataBlock(const std::vector<SizeType>& dataShape,
+                        const std::vector<SizeType>& positionOffset,
+                        const AQNWB::IO::BaseDataType& type,
+                        const void* data);
+
+  /**
+   * @brief Gets a const pointer to the HDF5 dataset.
+   * @return A const pointer to the HDF5 dataset.
+   */
+  inline const H5::DataSet* getDataSet() const { return m_dataset.get(); }
+
+private:
+  /**
+   * @brief Return status of HDF5 operations.
+   */
+  Status checkStatus(int status);
+
+  /**
+   * @brief Pointer to an extendable HDF5 dataset
+   */
+  std::unique_ptr<H5::DataSet> m_dataset;
+};
+}  // namespace AQNWB::IO::HDF5
diff --git a/src/nwb/NWBFile.cpp b/src/nwb/NWBFile.cpp
index 9e2ed943..20bd0b1e 100644
--- a/src/nwb/NWBFile.cpp
+++ b/src/nwb/NWBFile.cpp
@@ -8,9 +8,9 @@
 
 #include "nwb/NWBFile.hpp"
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Utils.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/device/Device.hpp"
 #include "nwb/ecephys/ElectricalSeries.hpp"
 #include "nwb/ecephys/SpikeEventSeries.hpp"
@@ -29,24 +29,22 @@ constexpr SizeType SPIKE_CHUNK_XSIZE =
 std::vector<SizeType> NWBFile::emptyContainerIndexes = {};
 
 // NWBFile
-
-NWBFile::NWBFile(const std::string& idText, std::shared_ptr<BaseIO> io)
+NWBFile::NWBFile(std::shared_ptr<IO::BaseIO> io)
     : Container("/", io)
-    , m_identifierText(idText)
-
 {
 }
 
 NWBFile::~NWBFile() {}
 
-Status NWBFile::initialize(const std::string description,
-                           const std::string dataCollection)
+Status NWBFile::initialize(const std::string& identifierText,
+                           const std::string& description,
+                           const std::string& dataCollection)
 {
   if (std::filesystem::exists(m_io->getFileName())) {
     return m_io->open(false);
   } else {
     m_io->open(true);
-    return createFileStructure(description, dataCollection);
+    return createFileStructure(identifierText, description, dataCollection);
   }
 }
 
@@ -55,16 +53,15 @@ Status NWBFile::finalize()
   return m_io->close();
 }
 
-Status NWBFile::createFileStructure(std::string description,
-                                    std::string dataCollection)
+Status NWBFile::createFileStructure(const std::string& identifierText,
+                                    const std::string& description,
+                                    const std::string& dataCollection)
 {
   if (!m_io->canModifyObjects()) {
     return Status::Failure;
   }
-
   m_io->createCommonNWBAttributes("/", "core", "NWBFile", "");
   m_io->createAttribute(AQNWB::SPEC::CORE::version, "/", "nwb_version");
-
   m_io->createGroup("/acquisition");
   m_io->createGroup("/analysis");
   m_io->createGroup("/processing");
@@ -77,10 +74,8 @@ Status NWBFile::createFileStructure(std::string description,
   if (dataCollection != "") {
     m_io->createStringDataSet("/general/data_collection", dataCollection);
   }
-
   m_io->createGroup("/specifications");
   m_io->createReferenceAttribute("/specifications", "/", ".specloc");
-
   cacheSpecifications(
       "core", AQNWB::SPEC::CORE::version, AQNWB::SPEC::CORE::specVariables);
   cacheSpecifications("hdmf-common",
@@ -89,22 +84,20 @@ Status NWBFile::createFileStructure(std::string description,
   cacheSpecifications("hdmf-experimental",
                       AQNWB::SPEC::HDMF_EXPERIMENTAL::version,
                       AQNWB::SPEC::HDMF_EXPERIMENTAL::specVariables);
-
   std::string time = getCurrentTime();
   std::vector<std::string> timeVec = {time};
   m_io->createStringDataSet("/file_create_date", timeVec);
   m_io->createStringDataSet("/session_description", description);
   m_io->createStringDataSet("/session_start_time", time);
   m_io->createStringDataSet("/timestamps_reference_time", time);
-  m_io->createStringDataSet("/identifier", m_identifierText);
-
+  m_io->createStringDataSet("/identifier", identifierText);
   return Status::Success;
 }
 
 Status NWBFile::createElectricalSeries(
     std::vector<Types::ChannelVector> recordingArrays,
     std::vector<std::string> recordingNames,
-    const BaseDataType& dataType,
+    const IO::BaseDataType& dataType,
     RecordingContainers* recordingContainers,
     std::vector<SizeType>& containerIndexes)
 {
@@ -141,27 +134,25 @@ Status NWBFile::createElectricalSeries(
     std::string electricalSeriesPath = acquisitionPath + "/" + recordingName;
 
     // Check if device exists for groupName, create device and electrode group
-    // if not
+    // if it does not
     if (!m_io->objectExists(devicePath)) {
-      Device device = Device(devicePath, m_io, "description", "unknown");
-      device.initialize();
+      Device device = Device(devicePath, m_io);
+      device.initialize("description", "unknown");
 
-      ElectrodeGroup elecGroup =
-          ElectrodeGroup(electrodePath, m_io, "description", "unknown", device);
-      elecGroup.initialize();
+      ElectrodeGroup elecGroup = ElectrodeGroup(electrodePath, m_io);
+      elecGroup.initialize("description", "unknown", device);
     }
 
     // Setup electrical series datasets
-    auto electricalSeries = std::make_unique<ElectricalSeries>(
-        electricalSeriesPath,
-        m_io,
+    auto electricalSeries =
+        std::make_unique<ElectricalSeries>(electricalSeriesPath, m_io);
+    electricalSeries->initialize(
         dataType,
         channelVector,
         "Stores continuously sampled voltage data from an "
         "extracellular ephys recording",
         SizeArray {0, channelVector.size()},
         SizeArray {CHUNK_XSIZE, 0});
-    electricalSeries->initialize();
     recordingContainers->addContainer(std::move(electricalSeries));
     containerIndexes.push_back(recordingContainers->size() - 1);
   }
@@ -178,7 +169,7 @@ Status NWBFile::createElectricalSeries(
 Status NWBFile::createSpikeEventSeries(
     std::vector<Types::ChannelVector> recordingArrays,
     std::vector<std::string> recordingNames,
-    const BaseDataType& dataType,
+    const IO::BaseDataType& dataType,
     RecordingContainers* recordingContainers,
     std::vector<SizeType>& containerIndexes)
 {
@@ -217,12 +208,11 @@ Status NWBFile::createSpikeEventSeries(
     // Check if device exists for groupName, create device and electrode group
     // if not
     if (!m_io->objectExists(devicePath)) {
-      Device device = Device(devicePath, m_io, "description", "unknown");
-      device.initialize();
+      Device device = Device(devicePath, m_io);
+      device.initialize("description", "unknown");
 
-      ElectrodeGroup elecGroup =
-          ElectrodeGroup(electrodePath, m_io, "description", "unknown", device);
-      elecGroup.initialize();
+      ElectrodeGroup elecGroup = ElectrodeGroup(electrodePath, m_io);
+      elecGroup.initialize("description", "unknown", device);
     }
 
     // Setup Spike Event Series datasets
@@ -236,15 +226,14 @@ Status NWBFile::createSpikeEventSeries(
       chunkSize = SizeArray {SPIKE_CHUNK_XSIZE, 1, 1};
     }
 
-    auto spikeEventSeries = std::make_unique<SpikeEventSeries>(
-        spikeEventSeriesPath,
-        m_io,
+    auto spikeEventSeries =
+        std::make_unique<SpikeEventSeries>(spikeEventSeriesPath, m_io);
+    spikeEventSeries->initialize(
         dataType,
         channelVector,
         "Stores spike waveforms from an extracellular ephys recording",
         dsetSize,
         chunkSize);
-    spikeEventSeries->initialize();
     recordingContainers->addContainer(std::move(spikeEventSeries));
     containerIndexes.push_back(recordingContainers->size() - 1);
   }
@@ -276,12 +265,12 @@ void NWBFile::cacheSpecifications(
 }
 
 // recording data factory method /
-std::unique_ptr<AQNWB::BaseRecordingData> NWBFile::createRecordingData(
-    BaseDataType type,
+std::unique_ptr<AQNWB::IO::BaseRecordingData> NWBFile::createRecordingData(
+    IO::BaseDataType type,
     const SizeArray& size,
     const SizeArray& chunking,
     const std::string& path)
 {
-  return std::unique_ptr<BaseRecordingData>(
+  return std::unique_ptr<IO::BaseRecordingData>(
       m_io->createArrayDataSet(type, size, chunking, path));
 }
diff --git a/src/nwb/NWBFile.hpp b/src/nwb/NWBFile.hpp
index ece6a64e..61855a9b 100644
--- a/src/nwb/NWBFile.hpp
+++ b/src/nwb/NWBFile.hpp
@@ -7,8 +7,8 @@
 #include <string_view>
 #include <vector>
 
-#include "BaseIO.hpp"
 #include "Types.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/RecordingContainers.hpp"
 #include "nwb/base/TimeSeries.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
@@ -30,10 +30,9 @@ class NWBFile : public Container
 public:
   /**
    * @brief Constructor for NWBFile class.
-   * @param idText The identifier text for the NWBFile.
    * @param io The shared pointer to the IO object.
    */
-  NWBFile(const std::string& idText, std::shared_ptr<BaseIO> io);
+  NWBFile(std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Deleted copy constructor to prevent construction-copying.
@@ -53,11 +52,14 @@ class NWBFile : public Container
   /**
    * @brief Initializes the NWB file by opening and setting up the file
    * structure.
+   *
+   * @param identifierText The identifier text for the NWBFile.
    * @param description A description of the NWBFile session.
    * @param dataCollection Information about the data collection methods.
    */
-  Status initialize(const std::string description = "a recording session",
-                    const std::string dataCollection = "");
+  Status initialize(const std::string& identifierText,
+                    const std::string& description = "a recording session",
+                    const std::string& dataCollection = "");
 
   /**
    * @brief Finalizes the NWB file by closing it.
@@ -84,7 +86,7 @@ class NWBFile : public Container
   Status createElectricalSeries(
       std::vector<Types::ChannelVector> recordingArrays,
       std::vector<std::string> recordingNames,
-      const BaseDataType& dataType = BaseDataType::I16,
+      const IO::BaseDataType& dataType = IO::BaseDataType::I16,
       RecordingContainers* recordingContainers = nullptr,
       std::vector<SizeType>& containerIndexes = emptyContainerIndexes);
 
@@ -105,7 +107,7 @@ class NWBFile : public Container
   Status createSpikeEventSeries(
       std::vector<Types::ChannelVector> recordingArrays,
       std::vector<std::string> recordingNames,
-      const BaseDataType& dataType = BaseDataType::I16,
+      const IO::BaseDataType& dataType = IO::BaseDataType::I16,
       RecordingContainers* recordingContainers = nullptr,
       std::vector<SizeType>& containerIndexes = emptyContainerIndexes);
 
@@ -115,12 +117,15 @@ class NWBFile : public Container
    * Note, this function will fail if the file is in a mode where
    * new objects cannot be added, which can be checked via
    * nwbfile.io->canModifyObjects()
+   *
+   * @param identifierText The identifier text for the NWBFile.
    * @param description A description of the NWBFile session.
    * @param dataCollection Information about the data collection methods.
    * @return Status The status of the file structure creation.
    */
-  Status createFileStructure(std::string description,
-                             std::string dataCollection);
+  Status createFileStructure(const std::string& identifierText,
+                             const std::string& description,
+                             const std::string& dataCollection);
 
 private:
   /**
@@ -129,11 +134,11 @@ class NWBFile : public Container
    * @param size The size of the dataset.
    * @param chunking The chunking size of the dataset.
    * @param path The location in the file of the new dataset.
-   * @return std::unique_ptr<BaseRecordingData> The unique pointer to the
+   * @return std::unique_ptr<IO::BaseRecordingData> The unique pointer to the
    * created recording data.
    */
-  std::unique_ptr<BaseRecordingData> createRecordingData(
-      BaseDataType type,
+  std::unique_ptr<IO::BaseRecordingData> createRecordingData(
+      IO::BaseDataType type,
       const SizeArray& size,
       const SizeArray& chunking,
       const std::string& path);
@@ -161,7 +166,6 @@ class NWBFile : public Container
    * @brief The ElectrodeTable for the file
    */
   std::unique_ptr<ElectrodeTable> m_electrodeTable;
-  const std::string m_identifierText;
 };
 
 }  // namespace AQNWB::NWB
\ No newline at end of file
diff --git a/src/nwb/base/TimeSeries.cpp b/src/nwb/base/TimeSeries.cpp
index a5158077..c28c300a 100644
--- a/src/nwb/base/TimeSeries.cpp
+++ b/src/nwb/base/TimeSeries.cpp
@@ -5,50 +5,41 @@ using namespace AQNWB::NWB;
 // TimeSeries
 
 /** Constructor */
-TimeSeries::TimeSeries(const std::string& path,
-                       std::shared_ptr<BaseIO> io,
-                       const BaseDataType& dataType,
-                       const std::string& unit,
-                       const std::string& description,
-                       const std::string& comments,
-                       const SizeArray& dsetSize,
-                       const SizeArray& chunkSize,
-                       const float& conversion,
-                       const float& resolution,
-                       const float& offset)
+TimeSeries::TimeSeries(const std::string& path, std::shared_ptr<IO::BaseIO> io)
     : Container(path, io)
-    , dataType(dataType)
-    , unit(unit)
-    , description(description)
-    , comments(comments)
-    , dsetSize(dsetSize)
-    , chunkSize(chunkSize)
-    , conversion(conversion)
-    , resolution(resolution)
-    , offset(offset)
 {
 }
 
 /** Destructor */
 TimeSeries::~TimeSeries() {}
 
-void TimeSeries::initialize()
+void TimeSeries::initialize(const IO::BaseDataType& dataType,
+                            const std::string& unit,
+                            const std::string& description,
+                            const std::string& comments,
+                            const SizeArray& dsetSize,
+                            const SizeArray& chunkSize,
+                            const float& conversion,
+                            const float& resolution,
+                            const float& offset)
 {
   Container::initialize();
 
+  this->dataType = dataType;
+
   // setup attributes
   m_io->createCommonNWBAttributes(m_path, "core", neurodataType, description);
   m_io->createAttribute(comments, m_path, "comments");
 
   // setup datasets
-  this->data = std::unique_ptr<BaseRecordingData>(m_io->createArrayDataSet(
+  this->data = std::unique_ptr<IO::BaseRecordingData>(m_io->createArrayDataSet(
       dataType, dsetSize, chunkSize, m_path + "/data"));
   m_io->createDataAttributes(m_path, conversion, resolution, unit);
 
   SizeArray tsDsetSize = {
       dsetSize[0]};  // timestamps match data along first dimension
   this->timestamps =
-      std::unique_ptr<BaseRecordingData>(m_io->createArrayDataSet(
+      std::unique_ptr<IO::BaseRecordingData>(m_io->createArrayDataSet(
           this->timestampsType, tsDsetSize, chunkSize, m_path + "/timestamps"));
   m_io->createTimestampsAttributes(m_path);
 }
diff --git a/src/nwb/base/TimeSeries.hpp b/src/nwb/base/TimeSeries.hpp
index 08537856..28fd746e 100644
--- a/src/nwb/base/TimeSeries.hpp
+++ b/src/nwb/base/TimeSeries.hpp
@@ -2,7 +2,8 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/ReadIO.hpp"
 #include "nwb/hdmf/base/Container.hpp"
 
 namespace AQNWB::NWB
@@ -17,30 +18,8 @@ class TimeSeries : public Container
    * @brief Constructor.
    * @param path The location of the TimeSeries in the file.
    * @param io A shared pointer to the IO object.
-   * @param dataType The data type to use for storing the recorded signal
-   * @param unit Unit for the electrical signal. Must be "volts"
-   * @param description The description of the TimeSeries.
-   * @param comments Human-readable comments about the TimeSeries
-   * @param dsetSize Initial size of the main dataset
-   * @param chunkSize Chunk size to use
-   * @param conversion Scalar to multiply each element in data to convert it to
-   *                   the specified ‘unit’
-   * @param resolution Smallest meaningful difference between values in data,
-   *                   stored in the specified by unit
-   * @param offset Scalar to add to the data after scaling by ‘conversion’ to
-   *               finalize its coercion to the specified ‘unit'
    */
-  TimeSeries(const std::string& path,
-             std::shared_ptr<BaseIO> io,
-             const BaseDataType& dataType,
-             const std::string& unit,
-             const std::string& description = "no description",
-             const std::string& comments = "no comments",
-             const SizeArray& dsetSize = SizeArray {0},
-             const SizeArray& chunkSize = SizeArray {1},
-             const float& conversion = 1.0f,
-             const float& resolution = -1.0f,
-             const float& offset = 0.0f);
+  TimeSeries(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Destructor
@@ -65,79 +44,79 @@ class TimeSeries : public Container
   /**
    * @brief Initializes the TimeSeries by creating NWB related attributes and
    * writing the description and comment metadata.
+   *
+   * @param dataType The data type to use for storing the recorded signal
+   * @param unit Unit for the electrical signal. Must be "volts"
+   * @param description The description of the TimeSeries.
+   * @param comments Human-readable comments about the TimeSeries
+   * @param dsetSize Initial size of the main dataset
+   * @param chunkSize Chunk size to use
+   * @param conversion Scalar to multiply each element in data to convert it to
+   *                   the specified ‘unit’
+   * @param resolution Smallest meaningful difference between values in data,
+   *                   stored in the specified by unit
+   * @param offset Scalar to add to the data after scaling by ‘conversion’ to
+   *               finalize its coercion to the specified ‘unit'
    */
-  void initialize();
+  void initialize(const IO::BaseDataType& dataType,
+                  const std::string& unit,
+                  const std::string& description = "no description",
+                  const std::string& comments = "no comments",
+                  const SizeArray& dsetSize = SizeArray {0},
+                  const SizeArray& chunkSize = SizeArray {1},
+                  const float& conversion = 1.0f,
+                  const float& resolution = -1.0f,
+                  const float& offset = 0.0f);
 
   /**
    * @brief Pointer to data values.
    */
-  std::unique_ptr<BaseRecordingData> data;
+  std::unique_ptr<IO::BaseRecordingData> data;
 
   /**
    * @brief Pointer to timestamp values.
    */
-  std::unique_ptr<BaseRecordingData> timestamps;
+  std::unique_ptr<IO::BaseRecordingData> timestamps;
 
   /**
    * @brief Data type of the data.
    */
-  BaseDataType dataType;
+  IO::BaseDataType dataType;
 
   /**
    * @brief Data type of the timestamps (float64).
    */
-  BaseDataType timestampsType = BaseDataType::F64;
-
-  /**
-   * @brief Base unit of measurement for working with the data. Actual stored
-   * values are not necessarily stored in these units. To access the data in
-   * these units, multiply ‘data’ by ‘conversion’ and add ‘offset’.
-   */
-  std::string unit;
-
-  /**
-   * @brief The description of the TimeSeries.
-   */
-  std::string description;
-
-  /**
-   * @brief Human-readable comments about the TimeSeries.
-   */
-  std::string comments;
-
-  /**
-   * @brief Size used in dataset creation. Can be expanded when writing if
-   * needed.
-   */
-  SizeArray dsetSize;
-
-  /**
-   * @brief Chunking size used in dataset creation.
-   */
-  SizeArray chunkSize;
-
-  /**
-   * @brief Scalar to multiply each element in data to convert it to the
-   * specified ‘unit’.
-   */
-  float conversion;
-
-  /**
-   * @brief Smallest meaningful difference between values in data, stored in the
-   * specified by unit.
-   */
-  float resolution;
-
-  /**
-   * @brief Scalar to add to the data after scaling by ‘conversion’ to finalize
-   * its coercion to the specified ‘unit’.
-   */
-  float offset;
-
-  /**
-   * @brief The starting time of the TimeSeries.
-   */
-  float startingTime = 0.0;
+  IO::BaseDataType timestampsType = IO::BaseDataType::F64;
+
+  inline std::string dataPath() const
+  {
+    return (m_path + std::string("/data"));
+  }
+
+  template<typename VTYPE = std::any>
+  inline std::unique_ptr<
+      IO::ReadDataWrapper<AQNWB::Types::StorageObjectType::Dataset, VTYPE>>
+  dataLazy() const
+  {
+    return std::make_unique<
+        IO::ReadDataWrapper<AQNWB::Types::StorageObjectType::Dataset, VTYPE>>(
+        m_io, this->dataPath());
+  }
+
+  inline std::string resolutionPath() const
+  {
+    return (this->dataPath() + std::string("/resolution"));
+  }
+
+  template<typename VTYPE = float>
+  inline std::unique_ptr<
+      IO::ReadDataWrapper<AQNWB::Types::StorageObjectType::Attribute, VTYPE>>
+  resolutionLazy() const
+  {
+    return std::make_unique<
+        IO::ReadDataWrapper<AQNWB::Types::StorageObjectType::Attribute, VTYPE>>(
+        m_io, this->resolutionPath());
+  }
 
 private:
   /**
diff --git a/src/nwb/device/Device.cpp b/src/nwb/device/Device.cpp
index 01036ad2..a343ec88 100644
--- a/src/nwb/device/Device.cpp
+++ b/src/nwb/device/Device.cpp
@@ -4,35 +4,19 @@ using namespace AQNWB::NWB;
 
 // Device
 /** Constructor */
-Device::Device(const std::string& path,
-               std::shared_ptr<BaseIO> io,
-               const std::string& description,
-               const std::string& manufacturer)
+Device::Device(const std::string& path, std::shared_ptr<IO::BaseIO> io)
     : Container(path, io)
-    , description(description)
-    , manufacturer(manufacturer)
 {
 }
 
 /** Destructor */
 Device::~Device() {}
 
-void Device::initialize()
+void Device::initialize(const std::string& description,
+                        const std::string& manufacturer)
 {
   Container::initialize();
 
   m_io->createCommonNWBAttributes(m_path, "core", "Device", description);
   m_io->createAttribute(manufacturer, m_path, "manufacturer");
 }
-
-// Getter for manufacturer
-std::string Device::getManufacturer() const
-{
-  return manufacturer;
-}
-
-// Getter for description
-std::string Device::getDescription() const
-{
-  return description;
-}
diff --git a/src/nwb/device/Device.hpp b/src/nwb/device/Device.hpp
index 74ae7062..120bcdbe 100644
--- a/src/nwb/device/Device.hpp
+++ b/src/nwb/device/Device.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/hdmf/base/Container.hpp"
 
 namespace AQNWB::NWB
@@ -18,13 +18,8 @@ class Device : public Container
    * @brief Constructor.
    * @param path The location of the device in the file.
    * @param io A shared pointer to the IO object.
-   * @param description The description of the device.
-   * @param manufacturer The manufacturer of the device.
    */
-  Device(const std::string& path,
-         std::shared_ptr<BaseIO> io,
-         const std::string& description,
-         const std::string& manufacturer);
+  Device(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Destructor
@@ -34,8 +29,12 @@ class Device : public Container
   /**
    * @brief Initializes the device by creating NWB related attributes and
    * writing the manufactor and description metadata.
+   *
+   * @param description The description of the device.
+   * @param manufacturer The manufacturer of the device.
    */
-  void initialize();
+  void initialize(const std::string& description,
+                  const std::string& manufacturer);
 
   /**
    * @brief Gets the manufacturer of the device.
@@ -48,16 +47,5 @@ class Device : public Container
    * @return The description of the device.
    */
   std::string getDescription() const;
-
-private:
-  /**
-   * @brief The description of the device.
-   */
-  std::string description;
-
-  /**
-   * @brief The manufacturer of the device.
-   */
-  std::string manufacturer;
 };
 }  // namespace AQNWB::NWB
diff --git a/src/nwb/ecephys/ElectricalSeries.cpp b/src/nwb/ecephys/ElectricalSeries.cpp
index 80a6ee88..2be4ab11 100644
--- a/src/nwb/ecephys/ElectricalSeries.cpp
+++ b/src/nwb/ecephys/ElectricalSeries.cpp
@@ -9,27 +9,8 @@ using namespace AQNWB::NWB;
 
 /** Constructor */
 ElectricalSeries::ElectricalSeries(const std::string& path,
-                                   std::shared_ptr<BaseIO> io,
-                                   const BaseDataType& dataType,
-                                   const Types::ChannelVector& channelVector,
-                                   const std::string& description,
-                                   const SizeArray& dsetSize,
-                                   const SizeArray& chunkSize,
-                                   const float& conversion,
-                                   const float& resolution,
-                                   const float& offset)
-    : TimeSeries(path,
-                 io,
-                 dataType,
-                 "volts",  // default unit for Electrical Series
-                 description,
-                 channelVector[0].getComments(),
-                 dsetSize,
-                 chunkSize,
-                 channelVector[0].getConversion(),
-                 resolution,
-                 offset)
-    , channelVector(channelVector)
+                                   std::shared_ptr<IO::BaseIO> io)
+    : TimeSeries(path, io)
 {
 }
 
@@ -37,9 +18,24 @@ ElectricalSeries::ElectricalSeries(const std::string& path,
 ElectricalSeries::~ElectricalSeries() {}
 
 /** Initialization function*/
-void ElectricalSeries::initialize()
+void ElectricalSeries::initialize(const IO::BaseDataType& dataType,
+                                  const Types::ChannelVector& channelVector,
+                                  const std::string& description,
+                                  const SizeArray& dsetSize,
+                                  const SizeArray& chunkSize,
+                                  const float& conversion,
+                                  const float& resolution,
+                                  const float& offset)
 {
-  TimeSeries::initialize();
+  TimeSeries::initialize(dataType,
+                         "volts",
+                         description,
+                         channelVector[0].getComments(),
+                         dsetSize,
+                         chunkSize,
+                         channelVector[0].getConversion(),
+                         resolution,
+                         offset);
 
   // setup variables based on number of channels
   std::vector<int> electrodeInds(channelVector.size());
@@ -51,32 +47,33 @@ void ElectricalSeries::initialize()
   samplesRecorded = SizeArray(channelVector.size(), 0);
 
   // make channel conversion dataset
-  channelConversion = std::unique_ptr<BaseRecordingData>(
-      m_io->createArrayDataSet(BaseDataType::F32,
+  channelConversion = std::unique_ptr<IO::BaseRecordingData>(
+      m_io->createArrayDataSet(IO::BaseDataType::F32,
                                SizeArray {1},
                                chunkSize,
                                getPath() + "/channel_conversion"));
   channelConversion->writeDataBlock(
       std::vector<SizeType>(1, channelVector.size()),
-      BaseDataType::F32,
+      IO::BaseDataType::F32,
       &channelConversions[0]);
   // add axis attribute for channel conversion
   const signed int axis_value = 1;
-  m_io->createAttribute(BaseDataType::I32,
+  m_io->createAttribute(IO::BaseDataType::I32,
                         &axis_value,
                         this->getPath() + "/channel_conversion",
                         "axis",
                         1);
 
   // make electrodes dataset
-  electrodesDataset = std::unique_ptr<BaseRecordingData>(
-      m_io->createArrayDataSet(BaseDataType::I32,
+  electrodesDataset = std::unique_ptr<IO::BaseRecordingData>(
+      m_io->createArrayDataSet(IO::BaseDataType::I32,
                                SizeArray {1},
                                chunkSize,
                                getPath() + "/electrodes"));
+
   electrodesDataset->writeDataBlock(
       std::vector<SizeType>(1, channelVector.size()),
-      BaseDataType::I32,
+      IO::BaseDataType::I32,
       &electrodeInds[0]);
   m_io->createCommonNWBAttributes(
       getPath() + "/electrodes", "hdmf-common", "DynamicTableRegion", "");
diff --git a/src/nwb/ecephys/ElectricalSeries.hpp b/src/nwb/ecephys/ElectricalSeries.hpp
index 597669be..f9d2efb4 100644
--- a/src/nwb/ecephys/ElectricalSeries.hpp
+++ b/src/nwb/ecephys/ElectricalSeries.hpp
@@ -2,8 +2,8 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/base/TimeSeries.hpp"
 
 namespace AQNWB::NWB
@@ -18,6 +18,17 @@ class ElectricalSeries : public TimeSeries
    * @brief Constructor.
    * @param path The location of the ElectricalSeries in the file.
    * @param io A shared pointer to the IO object.
+   */
+  ElectricalSeries(const std::string& path, std::shared_ptr<IO::BaseIO> io);
+
+  /**
+   * @brief Destructor
+   */
+  ~ElectricalSeries();
+
+  /**
+   * @brief Initializes the Electrical Series
+   *
    * @param dataType The data type to use for storing the recorded voltage
    * @param channelVector The electrodes to use for recording
    * @param description The description of the TimeSeries.
@@ -35,26 +46,14 @@ class ElectricalSeries : public TimeSeries
    * @param offset Scalar to add to the data after scaling by ‘conversion’ to
    *               finalize its coercion to the specified ‘unit'
    */
-  ElectricalSeries(const std::string& path,
-                   std::shared_ptr<BaseIO> io,
-                   const BaseDataType& dataType,
-                   const Types::ChannelVector& channelVector,
-                   const std::string& description,
-                   const SizeArray& dsetSize,
-                   const SizeArray& chunkSize,
-                   const float& conversion = 1.0f,
-                   const float& resolution = -1.0f,
-                   const float& offset = 0.0f);
-
-  /**
-   * @brief Destructor
-   */
-  ~ElectricalSeries();
-
-  /**
-   * @brief Initializes the Electrical Series
-   */
-  void initialize();
+  void initialize(const IO::BaseDataType& dataType,
+                  const Types::ChannelVector& channelVector,
+                  const std::string& description,
+                  const SizeArray& dsetSize,
+                  const SizeArray& chunkSize,
+                  const float& conversion = 1.0f,
+                  const float& resolution = -1.0f,
+                  const float& offset = 0.0f);
 
   /**
    * @brief Writes a channel to an ElectricalSeries dataset.
@@ -77,12 +76,12 @@ class ElectricalSeries : public TimeSeries
   /**
    * @brief Pointer to channel-specific conversion factor dataset.
    */
-  std::unique_ptr<BaseRecordingData> channelConversion;
+  std::unique_ptr<IO::BaseRecordingData> channelConversion;
 
   /**
    * @brief Pointer to electrodes dataset.
    */
-  std::unique_ptr<BaseRecordingData> electrodesDataset;
+  std::unique_ptr<IO::BaseRecordingData> electrodesDataset;
 
 private:
   /**
diff --git a/src/nwb/ecephys/SpikeEventSeries.cpp b/src/nwb/ecephys/SpikeEventSeries.cpp
index 7c0c53ce..e6d47240 100644
--- a/src/nwb/ecephys/SpikeEventSeries.cpp
+++ b/src/nwb/ecephys/SpikeEventSeries.cpp
@@ -6,35 +6,31 @@ using namespace AQNWB::NWB;
 
 /** Constructor */
 SpikeEventSeries::SpikeEventSeries(const std::string& path,
-                                   std::shared_ptr<BaseIO> io,
-                                   const BaseDataType& dataType,
-                                   const Types::ChannelVector& channelVector,
-                                   const std::string& description,
-                                   const SizeArray& dsetSize,
-                                   const SizeArray& chunkSize,
-                                   const float& conversion,
-                                   const float& resolution,
-                                   const float& offset)
-    : ElectricalSeries(path,
-                       io,
-                       dataType,
-                       channelVector,
-                       description,
-                       dsetSize,
-                       chunkSize,
-                       conversion,
-                       resolution,
-                       offset)
+                                   std::shared_ptr<IO::BaseIO> io)
+    : ElectricalSeries(path, io)
 {
 }
 
 /** Destructor */
 SpikeEventSeries::~SpikeEventSeries() {}
 
-void SpikeEventSeries::initialize()
+void SpikeEventSeries::initialize(const IO::BaseDataType& dataType,
+                                  const Types::ChannelVector& channelVector,
+                                  const std::string& description,
+                                  const SizeArray& dsetSize,
+                                  const SizeArray& chunkSize,
+                                  const float& conversion,
+                                  const float& resolution,
+                                  const float& offset)
 {
-  ElectricalSeries::initialize();
-
+  ElectricalSeries::initialize(dataType,
+                               channelVector,
+                               description,
+                               dsetSize,
+                               chunkSize,
+                               conversion,
+                               resolution,
+                               offset);
   this->eventsRecorded = 0;
 }
 
diff --git a/src/nwb/ecephys/SpikeEventSeries.hpp b/src/nwb/ecephys/SpikeEventSeries.hpp
index cbd541da..4cb7cdbb 100644
--- a/src/nwb/ecephys/SpikeEventSeries.hpp
+++ b/src/nwb/ecephys/SpikeEventSeries.hpp
@@ -2,8 +2,8 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/ecephys/ElectricalSeries.hpp"
 
 namespace AQNWB::NWB
@@ -19,9 +19,21 @@ class SpikeEventSeries : public ElectricalSeries
    * @brief Constructor.
    * @param path The location of the SpikeEventSeries in the file.
    * @param io A shared pointer to the IO object.
+   */
+  SpikeEventSeries(const std::string& path, std::shared_ptr<IO::BaseIO> io);
+
+  /**
+   * @brief Destructor
+   */
+  ~SpikeEventSeries();
+
+  /**
+   * @brief Initializes the SpikeEventSeries
+   *
    * @param dataType The data type to use for storing the recorded voltage
    * @param channelVector The electrodes to use for recording
-   * @param description The description of the TimeSeries.
+   * @param description The description of the SpikeEventSeries, should describe
+   * how events were detected.
    * @param dsetSize Initial size of the main dataset. This must be a vector
    *                 with two elements. The first element specifies the length
    *                 in time and the second element must be equal to the
@@ -36,29 +48,18 @@ class SpikeEventSeries : public ElectricalSeries
    * @param offset Scalar to add to the data after scaling by ‘conversion’ to
    *               finalize its coercion to the specified ‘unit'
    */
-  SpikeEventSeries(const std::string& path,
-                   std::shared_ptr<BaseIO> io,
-                   const BaseDataType& dataType,
-                   const Types::ChannelVector& channelVector,
-                   const std::string& description,
-                   const SizeArray& dsetSize,
-                   const SizeArray& chunkSize,
-                   const float& conversion = 1.0f,
-                   const float& resolution = -1.0f,
-                   const float& offset = 0.0f);
-
-  /**
-   * @brief Destructor
-   */
-  ~SpikeEventSeries();
-
-  /**
-   * @brief Initializes the Electrical Series
-   */
-  void initialize();
+  void initialize(const IO::BaseDataType& dataType,
+                  const Types::ChannelVector& channelVector,
+                  const std::string& description,
+                  const SizeArray& dsetSize,
+                  const SizeArray& chunkSize,
+                  const float& conversion = 1.0f,
+                  const float& resolution = -1.0f,
+                  const float& offset = 0.0f);
 
   /**
    * @brief Write a single spike series event
+   *
    * @param numSamples The number of samples in the event
    * @param numChannels The number of channels in the event
    * @param data The data of the event
diff --git a/src/nwb/file/ElectrodeGroup.cpp b/src/nwb/file/ElectrodeGroup.cpp
index 0d283654..c8f7617e 100644
--- a/src/nwb/file/ElectrodeGroup.cpp
+++ b/src/nwb/file/ElectrodeGroup.cpp
@@ -6,21 +6,17 @@ using namespace AQNWB::NWB;
 
 /** Constructor */
 ElectrodeGroup::ElectrodeGroup(const std::string& path,
-                               std::shared_ptr<BaseIO> io,
-                               const std::string& description,
-                               const std::string& location,
-                               const Device& device)
+                               std::shared_ptr<IO::BaseIO> io)
     : Container(path, io)
-    , description(description)
-    , location(location)
-    , device(device)
 {
 }
 
 /** Destructor */
 ElectrodeGroup::~ElectrodeGroup() {}
 
-void ElectrodeGroup::initialize()
+void ElectrodeGroup::initialize(const std::string& description,
+                                const std::string& location,
+                                const Device& device)
 {
   Container::initialize();
 
@@ -29,21 +25,3 @@ void ElectrodeGroup::initialize()
   m_io->createAttribute(location, m_path, "location");
   m_io->createLink("/" + m_path + "/device", "/" + device.getPath());
 }
-
-// Getter for description
-std::string ElectrodeGroup::getDescription() const
-{
-  return description;
-}
-
-// Getter for location
-std::string ElectrodeGroup::getLocation() const
-{
-  return location;
-}
-
-// Getter for device
-const Device& ElectrodeGroup::getDevice() const
-{
-  return device;
-}
diff --git a/src/nwb/file/ElectrodeGroup.hpp b/src/nwb/file/ElectrodeGroup.hpp
index 4f4c55ca..e69c8aef 100644
--- a/src/nwb/file/ElectrodeGroup.hpp
+++ b/src/nwb/file/ElectrodeGroup.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/device/Device.hpp"
 #include "nwb/hdmf/base/Container.hpp"
 
@@ -19,16 +19,8 @@ class ElectrodeGroup : public Container
    * @brief Constructor.
    * @param path The location in the file of the electrode group.
    * @param io A shared pointer to the IO object.
-   * @param description The description of the electrode group.
-   * @param location The location of electrode group within the subject e.g.
-   * brain region.
-   * @param device The device associated with the electrode group.
    */
-  ElectrodeGroup(const std::string& path,
-                 std::shared_ptr<BaseIO> io,
-                 const std::string& description,
-                 const std::string& location,
-                 const Device& device);
+  ElectrodeGroup(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Destructor.
@@ -40,42 +32,14 @@ class ElectrodeGroup : public Container
    *
    * Initializes the ElectrodeGroup by creating NWB related attributes and
    * linking to the Device object.
+   *
+   * @param description The description of the electrode group.
+   * @param location The location of electrode group within the subject e.g.
+   * brain region.
+   * @param device The device associated with the electrode group.
    */
-  void initialize();
-
-  /**
-   * @brief Gets the description of the electrode group.
-   * @return The description of the electrode group.
-   */
-  std::string getDescription() const;
-
-  /**
-   * @brief Gets the location of the electrode group.
-   * @return The location of the electrode group.
-   */
-  std::string getLocation() const;
-
-  /**
-   * @brief Gets the device associated with the electrode group.
-   * @return The device associated with the electrode group.
-   */
-  const Device& getDevice() const;
-
-private:
-  /**
-   * @brief The description of the electrode group.
-   */
-  std::string description;
-
-  /**
-   * @brief The location of electrode group within the subject e.g. brain
-   * region.
-   */
-  std::string location;
-
-  /**
-   * @brief The device associated with the electrode group.
-   */
-  Device device;
+  void initialize(const std::string& description,
+                  const std::string& location,
+                  const Device& device);
 };
 }  // namespace AQNWB::NWB
diff --git a/src/nwb/file/ElectrodeTable.cpp b/src/nwb/file/ElectrodeTable.cpp
index 0f162bce..7ffbe68a 100644
--- a/src/nwb/file/ElectrodeTable.cpp
+++ b/src/nwb/file/ElectrodeTable.cpp
@@ -7,34 +7,40 @@ using namespace AQNWB::NWB;
 // ElectrodeTable
 
 /** Constructor */
-ElectrodeTable::ElectrodeTable(std::shared_ptr<BaseIO> io,
-                               const std::string& description)
+ElectrodeTable::ElectrodeTable(std::shared_ptr<IO::BaseIO> io)
     : DynamicTable(electrodeTablePath,  // use the electrodeTablePath
                    io,
-                   description,
                    {"group", "group_name", "location"})
 {
 }
 
+ElectrodeTable::ElectrodeTable(const std::string& path,
+                               std::shared_ptr<IO::BaseIO> io)
+    : DynamicTable(electrodeTablePath,  // use the electrodeTablePath
+                   io)
+{
+  assert(path == electrodeTablePath);
+}
+
 /** Destructor */
 ElectrodeTable::~ElectrodeTable() {}
 
 /** Initialization function*/
-void ElectrodeTable::initialize()
+void ElectrodeTable::initialize(const std::string& description)
 {
   // create group
-  DynamicTable::initialize();
+  DynamicTable::initialize(description);
 
   electrodeDataset->setDataset(
-      std::unique_ptr<BaseRecordingData>(m_io->createArrayDataSet(
-          BaseDataType::I32, SizeArray {1}, SizeArray {1}, m_path + "id")));
-  groupNamesDataset->setDataset(std::unique_ptr<BaseRecordingData>(
-      m_io->createArrayDataSet(BaseDataType::STR(250),
+      std::unique_ptr<IO::BaseRecordingData>(m_io->createArrayDataSet(
+          IO::BaseDataType::I32, SizeArray {1}, SizeArray {1}, m_path + "id")));
+  groupNamesDataset->setDataset(std::unique_ptr<IO::BaseRecordingData>(
+      m_io->createArrayDataSet(IO::BaseDataType::STR(250),
                                SizeArray {0},
                                SizeArray {1},
                                m_path + "group_name")));
-  locationsDataset->setDataset(std::unique_ptr<BaseRecordingData>(
-      m_io->createArrayDataSet(BaseDataType::STR(250),
+  locationsDataset->setDataset(std::unique_ptr<IO::BaseRecordingData>(
+      m_io->createArrayDataSet(IO::BaseDataType::STR(250),
                                SizeArray {0},
                                SizeArray {1},
                                m_path + "location")));
diff --git a/src/nwb/file/ElectrodeTable.hpp b/src/nwb/file/ElectrodeTable.hpp
index 6c3775fa..c0e81404 100644
--- a/src/nwb/file/ElectrodeTable.hpp
+++ b/src/nwb/file/ElectrodeTable.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/hdmf/table/DynamicTable.hpp"
 #include "nwb/hdmf/table/ElementIdentifiers.hpp"
 #include "nwb/hdmf/table/VectorData.hpp"
@@ -18,12 +18,12 @@ class ElectrodeTable : public DynamicTable
   /**
    * @brief Constructor.
    * @param io The shared pointer to the BaseIO object.
-   * @param description The description of the table (default: "metadata about
    * extracellular electrodes").
    */
-  ElectrodeTable(std::shared_ptr<BaseIO> io,
-                 const std::string& description =
-                     "metadata about extracellular electrodes");
+  ElectrodeTable(std::shared_ptr<IO::BaseIO> io);
+
+  // required so we can call create
+  ElectrodeTable(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Destructor.
@@ -35,8 +35,11 @@ class ElectrodeTable : public DynamicTable
    *
    * Initializes the ElectrodeTable by creating NWB related attributes and
    * adding required columns.
+   *
+   *  @param description The description of the table (default: "metadata about
    */
-  void initialize();
+  void initialize(const std::string& description =
+                      "metadata about extracellular electrodes");
 
   /**
    * @brief Finalizes the ElectrodeTable.
diff --git a/src/nwb/hdmf/base/Container.cpp b/src/nwb/hdmf/base/Container.cpp
index f2221cb8..f2fe49b7 100644
--- a/src/nwb/hdmf/base/Container.cpp
+++ b/src/nwb/hdmf/base/Container.cpp
@@ -5,7 +5,7 @@ using namespace AQNWB::NWB;
 // Container
 
 /** Constructor */
-Container::Container(const std::string& path, std::shared_ptr<BaseIO> io)
+Container::Container(const std::string& path, std::shared_ptr<IO::BaseIO> io)
     : m_path(path)
     , m_io(io)
 {
diff --git a/src/nwb/hdmf/base/Container.hpp b/src/nwb/hdmf/base/Container.hpp
index b1ecdc6e..8e195c52 100644
--- a/src/nwb/hdmf/base/Container.hpp
+++ b/src/nwb/hdmf/base/Container.hpp
@@ -3,7 +3,7 @@
 #include <memory>
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 
 namespace AQNWB::NWB
 {
@@ -19,7 +19,7 @@ class Container
    * @param path The path of the container.
    * @param io A shared pointer to the IO object.
    */
-  Container(const std::string& path, std::shared_ptr<BaseIO> io);
+  Container(const std::string& path, std::shared_ptr<IO::BaseIO> io);
 
   /**
    * @brief Destructor.
@@ -37,6 +37,15 @@ class Container
    */
   inline std::string getPath() const { return m_path; }
 
+  template<typename T>
+  inline static std::unique_ptr<T> create(const std::string& path,
+                                          std::shared_ptr<IO::BaseIO> io)
+  {
+    static_assert(std::is_base_of<Container, T>::value,
+                  "T must be a derived class of Container");
+    return std::unique_ptr<T>(new T(path, io));
+  }
+
 protected:
   /**
    * @brief The path of the container.
@@ -46,6 +55,6 @@ class Container
   /**
    * @brief A shared pointer to the IO object.
    */
-  std::shared_ptr<BaseIO> m_io;
+  std::shared_ptr<IO::BaseIO> m_io;
 };
 }  // namespace AQNWB::NWB
diff --git a/src/nwb/hdmf/base/Data.hpp b/src/nwb/hdmf/base/Data.hpp
index 833b5f87..86a6e129 100644
--- a/src/nwb/hdmf/base/Data.hpp
+++ b/src/nwb/hdmf/base/Data.hpp
@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 
 namespace AQNWB::NWB
 {
@@ -30,7 +30,7 @@ class Data
    *
    * @param dataset The rvalue unique pointer to the BaseRecordingData object
    */
-  inline void setDataset(std::unique_ptr<BaseRecordingData>&& dataset)
+  inline void setDataset(std::unique_ptr<IO::BaseRecordingData>&& dataset)
   {
     m_dataset = std::move(dataset);
   }
@@ -40,6 +40,6 @@ class Data
    */
   inline bool isInitialized() { return m_dataset != nullptr; }
 
-  std::unique_ptr<BaseRecordingData> m_dataset;
+  std::unique_ptr<IO::BaseRecordingData> m_dataset;
 };
 }  // namespace AQNWB::NWB
diff --git a/src/nwb/hdmf/table/DynamicTable.cpp b/src/nwb/hdmf/table/DynamicTable.cpp
index 8fa217d4..e8b769e8 100644
--- a/src/nwb/hdmf/table/DynamicTable.cpp
+++ b/src/nwb/hdmf/table/DynamicTable.cpp
@@ -6,11 +6,9 @@ using namespace AQNWB::NWB;
 
 /** Constructor */
 DynamicTable::DynamicTable(const std::string& path,
-                           std::shared_ptr<BaseIO> io,
-                           const std::string& description,
+                           std::shared_ptr<IO::BaseIO> io,
                            const std::vector<std::string>& colNames)
     : Container(path, io)
-    , m_description(description)
     , m_colNames(colNames)
 {
 }
@@ -19,9 +17,10 @@ DynamicTable::DynamicTable(const std::string& path,
 DynamicTable::~DynamicTable() {}
 
 /** Initialization function*/
-void DynamicTable::initialize()
+void DynamicTable::initialize(const std::string& description)
 {
   Container::initialize();
+  this->m_description = description;
 
   m_io->createCommonNWBAttributes(
       m_path, "hdmf-common", "DynamicTable", getDescription());
@@ -41,7 +40,7 @@ void DynamicTable::addColumn(const std::string& name,
     for (SizeType i = 0; i < values.size(); i++)
       vectorData->m_dataset->writeDataBlock(
           std::vector<SizeType>(1, 1),
-          BaseDataType::STR(values[i].size() + 1),
+          IO::BaseDataType::STR(values[i].size() + 1),
           values[i].c_str());  // TODO - add tests for this
     m_io->createCommonNWBAttributes(
         m_path + name, "hdmf-common", "VectorData", colDescription);
@@ -55,7 +54,9 @@ void DynamicTable::setRowIDs(std::unique_ptr<ElementIdentifiers>& elementIDs,
     std::cerr << "ElementIdentifiers dataset is not initialized" << std::endl;
   } else {
     elementIDs->m_dataset->writeDataBlock(
-        std::vector<SizeType>(1, values.size()), BaseDataType::I32, &values[0]);
+        std::vector<SizeType>(1, values.size()),
+        IO::BaseDataType::I32,
+        &values[0]);
     m_io->createCommonNWBAttributes(
         m_path + "id", "hdmf-common", "ElementIdentifiers");
   }
diff --git a/src/nwb/hdmf/table/DynamicTable.hpp b/src/nwb/hdmf/table/DynamicTable.hpp
index 0148c756..bfef85b5 100644
--- a/src/nwb/hdmf/table/DynamicTable.hpp
+++ b/src/nwb/hdmf/table/DynamicTable.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "BaseIO.hpp"
+#include "io/BaseIO.hpp"
 #include "nwb/hdmf/base/Container.hpp"
 #include "nwb/hdmf/table/ElementIdentifiers.hpp"
 #include "nwb/hdmf/table/VectorData.hpp"
@@ -23,12 +23,13 @@ class DynamicTable : public Container
    * @brief Constructor.
    * @param path The location of the table in the file.
    * @param io A shared pointer to the IO object.
-   * @param description The description of the table (optional).
+   * @param colNames Set the names of the columns for the table
    */
-  DynamicTable(const std::string& path,
-               std::shared_ptr<BaseIO> io,
-               const std::string& description,
-               const std::vector<std::string>& colNames);
+  DynamicTable(
+      const std::string& path,
+      std::shared_ptr<IO::BaseIO> io,
+      const std::vector<std::string>& colNames =
+          {});  // TODO Need to remove colNames here and move it to initialize
 
   /**
    * @brief Destructor
@@ -38,8 +39,10 @@ class DynamicTable : public Container
   /**
    * @brief Initializes the `DynamicTable` object by creating NWB attributes and
    * column names.
+   *
+   * @param description The description of the table (optional).
    */
-  void initialize();
+  void initialize(const std::string& description);
 
   /**
    * @brief Adds a column of vector string data to the table.
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1add110d..dc0fb929 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ add_executable(aqnwb_test
     examples/test_HDF5IO_examples.cpp
     examples/test_example.cpp
     examples/testWorkflowExamples.cpp
+    examples/test_ecephys_data_read.cpp
 )
 
 # Ensure the aqnwb_test target can include headers from the current directory
diff --git a/tests/examples/testWorkflowExamples.cpp b/tests/examples/testWorkflowExamples.cpp
index 9edde1cb..0a2eec5f 100644
--- a/tests/examples/testWorkflowExamples.cpp
+++ b/tests/examples/testWorkflowExamples.cpp
@@ -1,11 +1,11 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Types.hpp"
 #include "Utils.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "nwb/NWBFile.hpp"
 #include "nwb/RecordingContainers.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
@@ -44,9 +44,8 @@ TEST_CASE("workflowExamples")
     // [example_workflow_recording_containers_snippet]
 
     // [example_workflow_nwbfile_snippet]
-    std::unique_ptr<NWB::NWBFile> nwbfile =
-        std::make_unique<NWB::NWBFile>(generateUuid(), io);
-    nwbfile->initialize();
+    std::unique_ptr<NWB::NWBFile> nwbfile = std::make_unique<NWB::NWBFile>(io);
+    nwbfile->initialize(generateUuid());
     // [example_workflow_nwbfile_snippet]
 
     // [example_workflow_datasets_snippet]
diff --git a/tests/examples/test_HDF5IO_examples.cpp b/tests/examples/test_HDF5IO_examples.cpp
index 3a978f60..01fb15c2 100644
--- a/tests/examples/test_HDF5IO_examples.cpp
+++ b/tests/examples/test_HDF5IO_examples.cpp
@@ -9,7 +9,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include "hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "nwb/NWBFile.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
 #include "testUtils.hpp"
@@ -25,7 +25,8 @@ TEST_CASE("SWMRmodeExamples", "[hdf5io]")
     // [example_HDF5_with_SWMR_mode]
     // create and open the HDF5 file. SWMR mode is used by default
     std::string path = getTestFilePath("testWithSWMRMode.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // add a dataset
@@ -71,9 +72,9 @@ TEST_CASE("SWMRmodeExamples", "[hdf5io]")
     // [example_HDF5_without_SWMR_mode]
     // create and open the HDF5 file. With SWMR mode explicitly disabled
     std::string path = getTestFilePath("testWithoutSWMRMode.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io =
-        std::make_unique<HDF5::HDF5IO>(path,
-                                       true  // Disable SWMR mode
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path,
+                                           true  // Disable SWMR mode
         );
     hdf5io->open();
 
diff --git a/tests/examples/test_ecephys_data_read.cpp b/tests/examples/test_ecephys_data_read.cpp
new file mode 100644
index 00000000..9a959881
--- /dev/null
+++ b/tests/examples/test_ecephys_data_read.cpp
@@ -0,0 +1,215 @@
+#include <H5Cpp.h>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_all.hpp>
+
+#include "Channel.hpp"
+#include "Types.hpp"
+#include "Utils.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
+#include "nwb/NWBFile.hpp"
+#include "nwb/RecordingContainers.hpp"
+#include "nwb/device/Device.hpp"
+#include "nwb/ecephys/ElectricalSeries.hpp"
+#include "nwb/file/ElectrodeGroup.hpp"
+#include "nwb/file/ElectrodeTable.hpp"
+#include "nwb/hdmf/base/Container.hpp"
+#include "testUtils.hpp"
+
+using namespace AQNWB;
+
+TEST_CASE("ElectricalSeriesReadExample", "[ecephys]")
+{
+  SECTION("ecephys data read example")
+  {
+    // [example_read_mockdata_snippet]
+    // setup mock data for writing
+    SizeType numSamples = 100;
+    SizeType numChannels = 2;
+    std::vector<Types::ChannelVector> mockArrays = getMockChannelArrays();
+    BaseDataType dataType = BaseDataType::F32;
+    std::vector<std::string> mockChannelNames =
+        getMockChannelArrayNames("esdata");
+    std::vector<std::vector<float>> mockData =
+        getMockData2D(numSamples, numChannels);
+    std::vector<double> mockTimestamps = getMockTimestamps(numSamples, 1);
+    // To verify that the data was written correctly, we here transpose the
+    // mockData (which is per channel) to the (time x channel) layout used
+    // in the ElectricalSeries in the NWB file so we can compare
+    std::vector<std::vector<float>> mockDataTransposed;
+    mockDataTransposed.resize(numSamples);
+    for (SizeType s = 0; s < numSamples; s++) {
+      mockDataTransposed[s].resize(numChannels);
+      for (SizeType c = 0; c < numChannels; c++) {
+        mockDataTransposed[s][c] = mockData[c][s];
+      }
+    }
+    // [example_read_mockdata_snippet]
+
+    // [example_read_create_file_snippet]
+    // setup io object
+    std::string path = getTestFilePath("ElectricalSeriesReadExample.h5");
+    std::shared_ptr<BaseIO> io = createIO("HDF5", path);
+
+    // setup the NWBFile
+    NWB::NWBFile nwbfile(io);
+    nwbfile.initialize(generateUuid());
+
+    // create the RecordingContainer for managing recordings
+    std::unique_ptr<NWB::RecordingContainers> recordingContainers =
+        std::make_unique<NWB::RecordingContainers>();
+
+    // create a new ElectricalSeries
+    Status resultCreate = nwbfile.createElectricalSeries(
+        mockArrays, mockChannelNames, dataType, recordingContainers.get());
+    REQUIRE(resultCreate == Status::Success);
+
+    // get the new ElectricalSeries
+    NWB::ElectricalSeries* electricalSeries =
+        static_cast<NWB::ElectricalSeries*>(
+            recordingContainers->getContainer(0));
+    REQUIRE(electricalSeries != nullptr);
+
+    // start recording
+    Status resultStart = io->startRecording();
+    REQUIRE(resultStart == Status::Success);
+
+    // write channel data
+    for (SizeType ch = 0; ch < numChannels; ++ch) {
+      electricalSeries->writeChannel(
+          ch, numSamples, mockData[ch].data(), mockTimestamps.data());
+    }
+    io->flush();
+    // [example_read_create_file_snippet]
+
+    // [example_read_get_data_wrapper_snippet]
+    // Get a ReadDatasetWrapper<float> for lazy reading of ElectricalSeries.data
+    // By specifying the value type as a template parameter allows us to read
+    // typed data
+    auto readDataWrapper = electricalSeries->dataLazy<float>();
+    // [example_read_get_data_wrapper_snippet]
+
+    // [example_read_get_datablock_snippet]
+    // Read the full  ElectricalSeries.data back
+    DataBlock<float> dataValues = readDataWrapper->values();
+    // [example_read_get_datablock_snippet]
+
+    // [example_read_validate_datablock_snippet]
+    // Check that the data we read has the expected size and shape
+    REQUIRE(dataValues.data.size() == (numSamples * numChannels));
+    REQUIRE(dataValues.shape[0] == numSamples);
+    REQUIRE(dataValues.shape[1] == numChannels);
+    REQUIRE(dataValues.typeIndex == typeid(float));
+
+    // Iterate through all the time steps
+    for (SizeType t = 0; t < numSamples; t++) {
+      // Get the data for the single time step t from the DataBlock
+      std::vector<float> selectedRange(
+          dataValues.data.begin() + (t * numChannels),
+          dataValues.data.begin() + ((t + 1) * numChannels));
+      // Check that the values are correct
+      REQUIRE_THAT(selectedRange,
+                   Catch::Matchers::Approx(mockDataTransposed[t]).margin(1));
+    }
+    // [example_read_validate_datablock_snippet]
+
+    // [example_read_get_boostarray_snippet]
+    // Use the boost multi-array feature to simply interaction with data
+    auto boostMulitArray = dataValues.as_multi_array<2>();
+    // [example_read_get_boostarray_snippet]
+
+    // [example_read_validate_boostarray_snippet]
+    // Iterate through all the time steps again, but now using the boost array
+    for (SizeType t = 0; t < numSamples; t++) {
+      // Access [t, :], i.e., get a 1D array with the data
+      // from all channels for time step t.
+      auto row_t = boostMulitArray[t];
+
+      // Compare to check that the data is correct.
+      std::vector<float> row_t_vector(
+          row_t.begin(), row_t.end());  // convert to std::vector for comparison
+      REQUIRE_THAT(row_t_vector,
+                   Catch::Matchers::Approx(mockDataTransposed[t]).margin(1));
+    }
+    // [example_read_validate_boostarray_snippet]
+
+    // [example_read_attribute_snippet]
+    // Get a ReadDataWrapper<ReadObjectType::Attribute, float> to read data
+    // lazily
+    auto readResolutionWrapper = electricalSeries->resolutionLazy();
+    // Read the data values
+    DataBlock<float> resolutionValueFloat = readResolutionWrapper->values();
+    REQUIRE(resolutionValueFloat.shape.empty());  // Scalar
+    REQUIRE(resolutionValueFloat.data.size() == 1);
+    REQUIRE(int(resolutionValueFloat.data[0]) == -1);
+    REQUIRE(resolutionValueFloat.typeIndex == typeid(float));
+    // [example_read_attribute_snippet]
+
+    // [example_read_get_data_wrapper_as_generic_snippet]
+    // Get a generic ReadDatasetWrapper<std::any> for lazy reading of
+    // ElectricalSeries.data
+    auto readDataWrapperGeneric = electricalSeries->dataLazy();
+    // Instead of using values() to read typed data, we can read data as generic
+    // data first via valuesGeneric
+    DataBlockGeneric dataValuesGeneric =
+        readDataWrapperGeneric->valuesGeneric();
+    // Note that the I/O backend determines the data type and allocates
+    // the memory for us. The std::type_index is stored in our data block as
+    // well
+    REQUIRE(dataValuesGeneric.typeIndex == typeid(float));
+    // We can then later convert the data block to a typed data block
+    DataBlock<float> dataValueFloat =
+        DataBlock<float>::fromGeneric(dataValuesGeneric);
+    // [example_read_get_data_wrapper_as_generic_snippet]
+
+    // [example_read_getpath_snippet]
+    // Reading the ElectricalSeries.data back (during the recording)
+    std::string electricalSeriesDataPath = electricalSeries->dataPath();
+    std::string electricalSeriesPath = electricalSeries->getPath();
+    REQUIRE(electricalSeriesDataPath == (electricalSeriesPath + "/data"));
+    // [example_read_getpath_snippet]
+
+    // [example_read_finish_recording_snippet]
+    // Stop the recording
+    io->stopRecording();
+    io->close();
+    // [example_read_finish_recording_snippet]
+
+    // [example_read_only_snippet]
+    // Open an I/O for reading
+    std::shared_ptr<BaseIO> readio = createIO("HDF5", path);
+
+    // To read from a specific TimeSeries we can just create it directly from
+    // the read IO Using NWB::Container::create we can create any NWB Container
+    // class. Alternatively, we can also construct the ElectricalSeries object
+    // ourselves
+    auto readElectricalSeries =
+        NWB::Container::create<NWB::ElectricalSeries>(path, io);
+
+    // Now we can read the data in the same way we did during write
+    auto readElectricalSeriesData = electricalSeries->dataLazy();
+    // [example_read_only_snippet]
+
+    // TODO Actually loading the data causes a segfault
+    // DataBlock<float> readDataValues = readDataWrapper->values<float>();
+    // auto readBoostMulitArray = readDataValues.as_multi_array<2>();
+
+    // Let's read the first 10 timesteps for the first two channels
+    /*DataBlock<float> dataSlice = readDataWrapper->values<float>(
+        {0, 0},  // start
+        {100, 1}  // count
+    );
+    REQUIRE(dataSlice.shape[0] == 100);
+    REQUIRE(dataSlice.shape[1] == 1);*/
+
+    // TODO Add an attribute getter (e.g., for ElectricalSeries.unit) and test
+    // that it works as well std::string esUnit = electricalSeries->unit();
+    // REQUIRE(esUnit == std::string("volts"));
+    // REQUIRE(unitValueGeneric.shape.size() == 0);
+
+    // TODO Check why reading the unit causes the below Assertion in HDF5IO to
+    // fail: (this->file->attrExists(dataPath)), function readAttribute, file
+    // HDF5IO.cpp, line 161. i.e., the attribute does not seem to exists so
+    // either the path is wrong or something is bad with the write?
+  }
+}
diff --git a/tests/examples/test_example.cpp b/tests/examples/test_example.cpp
index 356ec41f..6f5c59f1 100644
--- a/tests/examples/test_example.cpp
+++ b/tests/examples/test_example.cpp
@@ -1,7 +1,7 @@
 // [example_all]
 #include <catch2/catch_test_macros.hpp>
 
-#include "hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "testUtils.hpp"
 
 TEST_CASE("SimpleExamples", "[hdf5io]")
@@ -10,8 +10,8 @@ TEST_CASE("SimpleExamples", "[hdf5io]")
   {
     std::string path = getTestFilePath("testWithSWMRMode.h5");
     // [example_hdf5io_code_snippet]
-    std::unique_ptr<AQNWB::HDF5::HDF5IO> hdf5io =
-        std::make_unique<AQNWB::HDF5::HDF5IO>(path);
+    std::unique_ptr<AQNWB::IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<AQNWB::IO::HDF5::HDF5IO>(path);
     // [example_hdf5io_code_snippet]
     hdf5io->open();
     hdf5io->close();
diff --git a/tests/testBase.cpp b/tests/testBase.cpp
index b3f46bc1..d9c64c0e 100644
--- a/tests/testBase.cpp
+++ b/tests/testBase.cpp
@@ -1,9 +1,10 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
-#include "BaseIO.hpp"
 #include "Types.hpp"
 #include "Utils.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5RecordingData.hpp"
 #include "nwb/base/TimeSeries.hpp"
 #include "testUtils.hpp"
 
@@ -27,20 +28,21 @@ TEST_CASE("TimeSeries", "[base]")
     std::string path = getTestFilePath("testTimeseries.h5");
     std::shared_ptr<BaseIO> io = createIO("HDF5", path);
     io->open();
-    NWB::TimeSeries ts = NWB::TimeSeries(dataPath, io, dataType, "unit");
-    ts.initialize();
+    NWB::TimeSeries ts = NWB::TimeSeries(dataPath, io);
+    ts.initialize(dataType, "unit");
 
     // Write data to file
     Status writeStatus =
         ts.writeData(dataShape, positionOffset, data.data(), timestamps.data());
     REQUIRE(writeStatus == Status::Success);
+    io->flush();
 
-    // Read data back from file
+    // Read timestamps back from file
     double* tsBuffer = new double[numSamples];
     std::unique_ptr<BaseRecordingData> tsDset =
         io->getDataSet(dataPath + "/timestamps");
-    std::unique_ptr<HDF5::HDF5RecordingData> tsH5Dataset(
-        dynamic_cast<HDF5::HDF5RecordingData*>(tsDset.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> tsH5Dataset(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(tsDset.release()));
     readH5DataBlock(tsH5Dataset->getDataSet(), timestampsType, tsBuffer);
     std::vector<double> tsRead(tsBuffer, tsBuffer + numSamples);
     delete[] tsBuffer;
@@ -50,8 +52,8 @@ TEST_CASE("TimeSeries", "[base]")
     float* dataBuffer = new float[numSamples];
     std::unique_ptr<BaseRecordingData> dataDset =
         io->getDataSet(dataPath + "/data");
-    std::unique_ptr<HDF5::HDF5RecordingData> dataH5Dataset(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dataDset.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> dataH5Dataset(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dataDset.release()));
     readH5DataBlock(dataH5Dataset->getDataSet(), dataType, dataBuffer);
     std::vector<float> dataRead(dataBuffer, dataBuffer + numSamples);
     delete[] dataBuffer;
diff --git a/tests/testEcephys.cpp b/tests/testEcephys.cpp
index 97b9418f..194bea18 100644
--- a/tests/testEcephys.cpp
+++ b/tests/testEcephys.cpp
@@ -2,11 +2,11 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Types.hpp"
 #include "Utils.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "nwb/device/Device.hpp"
 #include "nwb/ecephys/ElectricalSeries.hpp"
 #include "nwb/ecephys/SpikeEventSeries.hpp"
@@ -47,21 +47,19 @@ TEST_CASE("ElectricalSeries", "[ecephys]")
     elecTable.initialize();
 
     // setup electrical series
-    NWB::ElectricalSeries es =
-        NWB::ElectricalSeries(dataPath,
-                              io,
-                              dataType,
-                              mockArrays[0],
-                              "no description",
-                              SizeArray {0, mockArrays[0].size()},
-                              SizeArray {1, 1});
-    es.initialize();
+    NWB::ElectricalSeries es = NWB::ElectricalSeries(dataPath, io);
+    es.initialize(dataType,
+                  mockArrays[0],
+                  "no description",
+                  SizeArray {0, mockArrays[0].size()},
+                  SizeArray {1, 1});
 
     // write channel data
     for (SizeType ch = 0; ch < numChannels; ++ch) {
       es.writeChannel(
           ch, numSamples, mockData[ch].data(), mockTimestamps.data());
     }
+    io->flush();
     io->close();
 
     // Read data back from file
@@ -102,15 +100,12 @@ TEST_CASE("ElectricalSeries", "[ecephys]")
     elecTable.initialize();
 
     // setup electrical series
-    NWB::ElectricalSeries es =
-        NWB::ElectricalSeries(dataPath,
-                              io,
-                              dataType,
-                              mockArrays[0],
-                              "no description",
-                              SizeArray {0, mockArrays[0].size()},
-                              SizeArray {1, 1});
-    es.initialize();
+    NWB::ElectricalSeries es = NWB::ElectricalSeries(dataPath, io);
+    es.initialize(dataType,
+                  mockArrays[0],
+                  "no description",
+                  SizeArray {0, mockArrays[0].size()},
+                  SizeArray {1, 1});
 
     // write channel data in segments
     for (SizeType ch = 0; ch < numChannels; ++ch) {
@@ -188,15 +183,12 @@ TEST_CASE("SpikeEventSeries", "[ecephys]")
     elecTable.initialize();
 
     // setup electrical series
-    NWB::SpikeEventSeries ses =
-        NWB::SpikeEventSeries(dataPath,
-                              io,
-                              dataType,
-                              mockArrays[0],
-                              "no description",
-                              SizeArray {0, numChannels, numSamples},
-                              SizeArray {8, 1, 1});
-    ses.initialize();
+    NWB::SpikeEventSeries ses = NWB::SpikeEventSeries(dataPath, io);
+    ses.initialize(dataType,
+                   mockArrays[0],
+                   "no description",
+                   SizeArray {0, numChannels, numSamples},
+                   SizeArray {8, 1, 1});
 
     // write channel data
     for (SizeType e = 0; e < numEvents; ++e) {
@@ -249,14 +241,12 @@ TEST_CASE("SpikeEventSeries", "[ecephys]")
     elecTable.initialize();
 
     // setup electrical series
-    NWB::SpikeEventSeries ses = NWB::SpikeEventSeries(dataPath,
-                                                      io,
-                                                      dataType,
-                                                      mockArrays[0],
-                                                      "no description",
-                                                      SizeArray {0, numSamples},
-                                                      SizeArray {8, 1});
-    ses.initialize();
+    NWB::SpikeEventSeries ses = NWB::SpikeEventSeries(dataPath, io);
+    ses.initialize(dataType,
+                   mockArrays[0],
+                   "no description",
+                   SizeArray {0, numSamples},
+                   SizeArray {8, 1});
 
     // write channel data
     for (SizeType e = 0; e < numEvents; ++e) {
diff --git a/tests/testFile.cpp b/tests/testFile.cpp
index ab52dc26..c7518390 100644
--- a/tests/testFile.cpp
+++ b/tests/testFile.cpp
@@ -1,9 +1,10 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Types.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5RecordingData.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
 #include "testUtils.hpp"
 
@@ -14,7 +15,7 @@ TEST_CASE("ElectrodeTable", "[ecephys]")
   SECTION("test initialization")
   {
     std::string filename = getTestFilePath("electrodeTable.h5");
-    std::shared_ptr<BaseIO> io = std::make_unique<HDF5::HDF5IO>(filename);
+    std::shared_ptr<BaseIO> io = std::make_unique<IO::HDF5::HDF5IO>(filename);
     io->open();
     io->createGroup("/general");
     io->createGroup("/general/extracellular_ephys");
@@ -36,8 +37,8 @@ TEST_CASE("ElectrodeTable", "[ecephys]")
     SizeType numChannels = 3;
     std::unique_ptr<BaseRecordingData> id_data =
         io->getDataSet(NWB::ElectrodeTable::electrodeTablePath + "id");
-    std::unique_ptr<HDF5::HDF5RecordingData> idDataset(
-        dynamic_cast<HDF5::HDF5RecordingData*>(id_data.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> idDataset(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(id_data.release()));
     int* buffer = new int[numChannels];
     readH5DataBlock(idDataset->getDataSet(), BaseDataType::I32, buffer);
     std::vector<SizeType> read_channels(buffer, buffer + numChannels);
@@ -50,7 +51,7 @@ TEST_CASE("ElectrodeTable", "[ecephys]")
     std::vector<Channel> channels = {};
 
     std::string filename = getTestFilePath("electrodeTableNoData.h5");
-    std::shared_ptr<BaseIO> io = std::make_unique<HDF5::HDF5IO>(filename);
+    std::shared_ptr<BaseIO> io = std::make_unique<IO::HDF5::HDF5IO>(filename);
     io->open();
     io->createGroup("/general");
     io->createGroup("/general/extracellular_ephys");
diff --git a/tests/testHDF5IO.cpp b/tests/testHDF5IO.cpp
index c49be19f..6bd3f507 100644
--- a/tests/testHDF5IO.cpp
+++ b/tests/testHDF5IO.cpp
@@ -8,10 +8,11 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Types.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5RecordingData.hpp"
 #include "nwb/NWBFile.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
 #include "testUtils.hpp"
@@ -23,7 +24,7 @@ TEST_CASE("writeGroup", "[hdf5io]")
 {
   // create and open file
   std::string filename = getTestFilePath("test_group.h5");
-  HDF5::HDF5IO hdf5io(filename);
+  IO::HDF5::HDF5IO hdf5io(filename);
   hdf5io.open();
 
   SECTION("initialize group")
@@ -41,7 +42,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
   {
     // open file
     std::string path = getTestFilePath("1DData1DDataset.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // Set up test data
@@ -59,8 +61,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
         dataShape, positionOffset, BaseDataType::I32, &testData[0]);
 
     std::unique_ptr<BaseRecordingData> dataRead = hdf5io->getDataSet(dataPath);
-    std::unique_ptr<HDF5::HDF5RecordingData> datasetRead1D(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dataRead.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> datasetRead1D(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dataRead.release()));
     int* buffer = new int[numSamples];
     readH5DataBlock(datasetRead1D->getDataSet(), BaseDataType::I32, buffer);
     std::vector<int> dataOut(buffer, buffer + numSamples);
@@ -74,7 +76,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
   {
     // open file
     std::string path = getTestFilePath("1DData2DDataset.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // Set up test data for 3D
@@ -95,8 +98,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
     // Read back the 1D data block from 3D dataset
     std::unique_ptr<BaseRecordingData> dataRead1D =
         hdf5io->getDataSet(dataPath);
-    std::unique_ptr<HDF5::HDF5RecordingData> dataset1DRead(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dataRead1D.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> dataset1DRead(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dataRead1D.release()));
     int* buffer1D = new int[numCols];
     readH5DataBlock(dataset1DRead->getDataSet(), BaseDataType::I32, buffer1D);
     std::vector<int> dataOut1D(buffer1D, buffer1D + numCols);
@@ -111,7 +114,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
   {
     // open file
     std::string path = getTestFilePath("2DData2DDataset.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // Set up test data for 2D
@@ -135,8 +139,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
     // Read back the 2D data block
     std::unique_ptr<BaseRecordingData> dsetRead2D =
         hdf5io->getDataSet(dataPath);
-    std::unique_ptr<HDF5::HDF5RecordingData> data2DRead(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dsetRead2D.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> data2DRead(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dsetRead2D.release()));
     int* buffer = new int[numRows * numCols];
     readH5DataBlock(data2DRead->getDataSet(), BaseDataType::I32, buffer);
     std::vector<int> dataOut(buffer, buffer + numRows * numCols);
@@ -151,7 +155,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
   {
     // open file
     std::string path = getTestFilePath("1DData3DDataset.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // Set up test data for 3D
@@ -172,8 +177,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
     // Read back the 1D data block from 3D dataset
     std::unique_ptr<BaseRecordingData> dataRead1D =
         hdf5io->getDataSet(dataPath);
-    std::unique_ptr<HDF5::HDF5RecordingData> dSet1D(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dataRead1D.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> dSet1D(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dataRead1D.release()));
     int* buffer1D =
         new int[width];  // Assuming 'width' is the size of the 1D data block
     readH5DataBlock(dSet1D->getDataSet(), BaseDataType::I32, buffer1D);
@@ -189,7 +194,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
   {
     // open file
     std::string path = getTestFilePath("2DData3DDataset.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     SizeType depth = 1, height = 2, width = 5;
@@ -209,8 +215,8 @@ TEST_CASE("writeDataset", "[hdf5io]")
     // Read back the 2D data block from 3D dataset
     std::unique_ptr<BaseRecordingData> dataRead2D =
         hdf5io->getDataSet(dataPath);
-    std::unique_ptr<HDF5::HDF5RecordingData> dSetRead2D(
-        dynamic_cast<HDF5::HDF5RecordingData*>(dataset.release()));
+    std::unique_ptr<IO::HDF5::HDF5RecordingData> dSetRead2D(
+        dynamic_cast<IO::HDF5::HDF5RecordingData*>(dataset.release()));
     int* buffer2D =
         new int[height * width];  // Assuming 'numRows' and 'numCols' define the
                                   // 2D data block size
@@ -228,7 +234,7 @@ TEST_CASE("writeAttributes", "[hdf5io]")
 {
   // create and open file
   std::string filename = getTestFilePath("test_attributes.h5");
-  HDF5::HDF5IO hdf5io(filename);
+  IO::HDF5::HDF5IO hdf5io(filename);
   hdf5io.open();
 
   hdf5io.createGroup("/data");
@@ -281,7 +287,8 @@ TEST_CASE("SWMRmode", "[hdf5io]")
   {
     // create and open file
     std::string path = getTestFilePath("testSWMRmode.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io = std::make_unique<HDF5::HDF5IO>(path);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path);
     hdf5io->open();
 
     // add a dataset
@@ -320,7 +327,7 @@ TEST_CASE("SWMRmode", "[hdf5io]")
       // write data block and flush to file
       std::vector<SizeType> dataShape = {numSamples};
       dataset->writeDataBlock(dataShape, BaseDataType::I32, &testData[0]);
-      H5Dflush(static_cast<HDF5::HDF5RecordingData*>(dataset.get())
+      H5Dflush(static_cast<IO::HDF5::HDF5RecordingData*>(dataset.get())
                    ->getDataSet()
                    ->getId());
 
@@ -354,8 +361,8 @@ TEST_CASE("SWMRmode", "[hdf5io]")
   {
     // create and open file with SWMR mode disabled
     std::string path = getTestFilePath("testSWMRmode.h5");
-    std::unique_ptr<HDF5::HDF5IO> hdf5io =
-        std::make_unique<HDF5::HDF5IO>(path, true);
+    std::unique_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_unique<IO::HDF5::HDF5IO>(path, true);
     hdf5io->open();
 
     // add a dataset
@@ -376,7 +383,7 @@ TEST_CASE("SWMRmode", "[hdf5io]")
       // write data block and flush to file
       std::vector<SizeType> dataShape = {numSamples};
       dataset->writeDataBlock(dataShape, BaseDataType::I32, &testData[0]);
-      H5Dflush(static_cast<HDF5::HDF5RecordingData*>(dataset.get())
+      H5Dflush(static_cast<IO::HDF5::HDF5RecordingData*>(dataset.get())
                    ->getDataSet()
                    ->getId());
 
@@ -408,11 +415,59 @@ TEST_CASE("SWMRmode", "[hdf5io]")
       std::vector<SizeType> dataShape = {numSamples};
       datasetPostRestart->writeDataBlock(
           dataShape, BaseDataType::I32, &testData[0]);
-      H5Dflush(static_cast<HDF5::HDF5RecordingData*>(datasetPostRestart.get())
-                   ->getDataSet()
-                   ->getId());
+      H5Dflush(
+          static_cast<IO::HDF5::HDF5RecordingData*>(datasetPostRestart.get())
+              ->getDataSet()
+              ->getId());
     }
 
     hdf5io->close();
   }
 }
+
+TEST_CASE("readDataset", "[hdf5io]")
+{
+  std::vector<int32_t> testData = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+  SECTION("read 1D data block of a 1D dataset")
+  {
+    // open file
+    std::string path = getTestFilePath("Read1DData1DDataset.h5");
+    std::shared_ptr<IO::HDF5::HDF5IO> hdf5io =
+        std::make_shared<IO::HDF5::HDF5IO>(path);
+    hdf5io->open();
+
+    // Set up test data
+    std::string dataPath = "/1DData1DDataset";
+    SizeType numSamples = 10;
+
+    // Create HDF5RecordingData object and dataset
+    std::unique_ptr<BaseRecordingData> dataset = hdf5io->createArrayDataSet(
+        BaseDataType::I32, SizeArray {0}, SizeArray {1}, dataPath);
+
+    // Write data block
+    std::vector<SizeType> dataShape = {numSamples};
+    std::vector<SizeType> positionOffset = {0};
+    dataset->writeDataBlock(
+        dataShape, positionOffset, BaseDataType::I32, &testData[0]);
+
+    // Confirm using HDF5IO readDataset that the data is correct
+    auto readData = hdf5io->readDataset(dataPath);
+    REQUIRE(readData.shape[0] == 10);
+    auto readDataTyped = DataBlock<int32_t>::fromGeneric(readData);
+    REQUIRE(readDataTyped.shape[0] == 10);
+    REQUIRE(readDataTyped.data == testData);
+
+    // Confirm using lazy read as well
+    auto readDataWrapper = std::make_unique<
+        ReadDataWrapper<AQNWB::Types::StorageObjectType::Dataset, int32_t>>(
+        hdf5io, dataPath);
+    auto readDataGeneric = readDataWrapper->valuesGeneric();
+    REQUIRE(readDataGeneric.shape[0] == 10);
+    auto readDataTypedV2 = readDataWrapper->values();
+    REQUIRE(readDataTypedV2.shape[0] == 10);
+    REQUIRE(readDataTypedV2.data == testData);
+
+    hdf5io->close();
+  }
+}
\ No newline at end of file
diff --git a/tests/testNWBFile.cpp b/tests/testNWBFile.cpp
index fe6b50ba..bcf9123c 100644
--- a/tests/testNWBFile.cpp
+++ b/tests/testNWBFile.cpp
@@ -1,8 +1,8 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "BaseIO.hpp"
 #include "Utils.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "nwb/NWBFile.hpp"
 #include "nwb/RecordingContainers.hpp"
 #include "nwb/base/TimeSeries.hpp"
@@ -16,9 +16,9 @@ TEST_CASE("saveNWBFile", "[nwb]")
   std::string filename = getTestFilePath("testSaveNWBFile.nwb");
 
   // initialize nwbfile object and create base structure
-  NWB::NWBFile nwbfile(generateUuid(),
-                       std::make_unique<HDF5::HDF5IO>(filename));
-  nwbfile.initialize();
+  auto io = std::make_shared<IO::HDF5::HDF5IO>(filename);
+  NWB::NWBFile nwbfile(io);
+  nwbfile.initialize(generateUuid());
   nwbfile.finalize();
 }
 
@@ -27,9 +27,10 @@ TEST_CASE("createElectricalSeries", "[nwb]")
   std::string filename = getTestFilePath("createElectricalSeries.nwb");
 
   // initialize nwbfile object and create base structure
-  std::shared_ptr<HDF5::HDF5IO> io = std::make_shared<HDF5::HDF5IO>(filename);
-  NWB::NWBFile nwbfile(generateUuid(), io);
-  nwbfile.initialize();
+  std::shared_ptr<IO::HDF5::HDF5IO> io =
+      std::make_shared<IO::HDF5::HDF5IO>(filename);
+  NWB::NWBFile nwbfile(io);
+  nwbfile.initialize(generateUuid());
 
   // create Electrical Series
   std::vector<Types::ChannelVector> mockArrays = getMockChannelArrays(1, 2);
@@ -72,8 +73,8 @@ TEST_CASE("createMultipleEcephysDatasets", "[nwb]")
 
   // initialize nwbfile object and create base structure
   std::shared_ptr<HDF5::HDF5IO> io = std::make_shared<HDF5::HDF5IO>(filename);
-  NWB::NWBFile nwbfile(generateUuid(), io);
-  nwbfile.initialize();
+  NWB::NWBFile nwbfile(io);
+  nwbfile.initialize(generateUuid());
 
   // create Electrical Series
   std::vector<Types::ChannelVector> mockArrays = getMockChannelArrays(1, 2);
@@ -136,16 +137,17 @@ TEST_CASE("setCanModifyObjectsMode", "[nwb]")
   std::string filename = getTestFilePath("testCanModifyObjectsMode.nwb");
 
   // initialize nwbfile object and create base structure with HDF5IO object
-  std::shared_ptr<HDF5::HDF5IO> io = std::make_shared<HDF5::HDF5IO>(filename);
-  NWB::NWBFile nwbfile(generateUuid(), io);
-  nwbfile.initialize();
+  std::shared_ptr<IO::HDF5::HDF5IO> io =
+      std::make_shared<IO::HDF5::HDF5IO>(filename);
+  NWB::NWBFile nwbfile(io);
+  nwbfile.initialize(generateUuid());
 
   // start recording
   Status resultStart = io->startRecording();
   REQUIRE(resultStart == Status::Success);
 
   // test that modifying the file structure after starting the recording fails
-  Status resultInitializePostStart = nwbfile.initialize();
+  Status resultInitializePostStart = nwbfile.initialize(generateUuid());
   REQUIRE(resultInitializePostStart == Status::Failure);
 
   // test that dataset creation fails after starting the recording
diff --git a/tests/testRecordingWorkflow.cpp b/tests/testRecordingWorkflow.cpp
index 69b2326f..b834c1ff 100644
--- a/tests/testRecordingWorkflow.cpp
+++ b/tests/testRecordingWorkflow.cpp
@@ -3,11 +3,11 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
-#include "BaseIO.hpp"
 #include "Channel.hpp"
 #include "Types.hpp"
 #include "Utils.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/BaseIO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 #include "nwb/NWBFile.hpp"
 #include "nwb/RecordingContainers.hpp"
 #include "nwb/file/ElectrodeTable.hpp"
@@ -44,9 +44,8 @@ TEST_CASE("writeContinuousData", "[recording]")
         std::make_unique<NWB::RecordingContainers>();
 
     // 3. create NWBFile object
-    std::unique_ptr<NWB::NWBFile> nwbfile =
-        std::make_unique<NWB::NWBFile>(generateUuid(), io);
-    nwbfile->initialize();
+    std::unique_ptr<NWB::NWBFile> nwbfile = std::make_unique<NWB::NWBFile>(io);
+    nwbfile->initialize(generateUuid());
 
     // 4. create datasets and add to recording containers
     nwbfile->createElectricalSeries(mockRecordingArrays,
diff --git a/tests/testUtils.hpp b/tests/testUtils.hpp
index 90440919..66c9c9ef 100644
--- a/tests/testUtils.hpp
+++ b/tests/testUtils.hpp
@@ -9,9 +9,10 @@
 
 #include "Channel.hpp"
 #include "Types.hpp"
-#include "hdf5/HDF5IO.hpp"
+#include "io/hdf5/HDF5IO.hpp"
 
 using namespace AQNWB;
+using namespace AQNWB::IO;
 namespace fs = std::filesystem;
 
 inline std::string getTestFilePath(std::string filename)
@@ -118,6 +119,6 @@ inline void readH5DataBlock(const H5::DataSet* dSet,
                             void* buffer)
 {
   H5::DataSpace fSpace = dSet->getSpace();
-  H5::DataType nativeType = HDF5::HDF5IO::getNativeType(type);
+  H5::DataType nativeType = IO::HDF5::HDF5IO::getNativeType(type);
   dSet->read(buffer, nativeType, fSpace, fSpace);
 }