diff --git a/include/albatross/Indexing b/include/albatross/Indexing
index 9563f424..dbd3f0f9 100644
--- a/include/albatross/Indexing
+++ b/include/albatross/Indexing
@@ -13,12 +13,14 @@
 #ifndef ALBATROSS_INDEXING_H
 #define ALBATROSS_INDEXING_H
 
+#include <future>
 #include "Dataset"
 
 #include <albatross/src/indexing/traits.hpp>
 #include <albatross/src/indexing/subset.hpp>
 #include <albatross/src/indexing/filter.hpp>
 #include <albatross/src/indexing/apply.hpp>
+#include <albatross/src/indexing/async_apply.hpp>
 #include <albatross/src/indexing/group_by.hpp>
 
 #endif
diff --git a/include/albatross/src/indexing/async_apply.hpp b/include/albatross/src/indexing/async_apply.hpp
new file mode 100644
index 00000000..f3df10b9
--- /dev/null
+++ b/include/albatross/src/indexing/async_apply.hpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2020 Swift Navigation Inc.
+ * Contact: Swift Navigation <dev@swiftnav.com>
+ *
+ * This source is subject to the license found in the file 'LICENSE' which must
+ * be distributed together with this source. All other rights reserved.
+ *
+ * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
+ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_
+#define INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_
+
+namespace albatross {
+
+// This method makes sure we don't accidentally call async with the
+// default mode which has some flaws:
+//
+// https://eli.thegreenplace.net/2016/the-promises-and-challenges-of-stdasync-task-based-parallelism-in-c11/
+template <typename F, typename... Ts>
+inline auto async_safe(F &&f, Ts &&... params) {
+  return std::async(std::launch::async, std::forward<F>(f),
+                    std::forward<Ts>(params)...);
+}
+
+template <typename ValueType, typename ApplyFunction,
+          typename ApplyType = typename details::value_only_apply_result<
+              ApplyFunction, ValueType>::type,
+          typename std::enable_if<details::is_valid_value_only_apply_function<
+                                      ApplyFunction, ValueType>::value &&
+                                      std::is_same<void, ApplyType>::value,
+                                  int>::type = 0>
+inline void async_apply(const std::vector<ValueType> &xs, ApplyFunction &&f) {
+  std::vector<std::future<void>> futures;
+  for (const ValueType &x : xs) {
+    futures.emplace_back(async_safe(f, x));
+  }
+  for (auto &f : futures) {
+    f.get();
+  }
+}
+
+template <typename ValueType, typename ApplyFunction,
+          typename ApplyType = typename details::value_only_apply_result<
+              ApplyFunction, ValueType>::type,
+          typename std::enable_if<details::is_valid_value_only_apply_function<
+                                      ApplyFunction, ValueType>::value &&
+                                      !std::is_same<void, ApplyType>::value,
+                                  int>::type = 0>
+inline auto async_apply(const std::vector<ValueType> &xs, ApplyFunction &&f) {
+  std::vector<std::future<ApplyType>> futures;
+  for (const ValueType &x : xs) {
+    futures.emplace_back(async_safe(f, x));
+  }
+
+  std::vector<ApplyType> output;
+  for (auto &f : futures) {
+    output.emplace_back(f.get());
+  }
+  return output;
+}
+
+// Map
+
+template <
+    template <typename...> class Map, typename KeyType, typename ValueType,
+    typename ApplyFunction,
+    typename ApplyType = typename details::key_value_apply_result<
+        ApplyFunction, KeyType, ValueType>::type,
+    typename std::enable_if<details::is_valid_key_value_apply_function<
+                                ApplyFunction, KeyType, ValueType>::value &&
+                                std::is_same<void, ApplyType>::value,
+                            int>::type = 0>
+inline void async_apply(const Map<KeyType, ValueType> &map, ApplyFunction &&f) {
+  std::vector<std::future<void>> futures;
+  for (const auto &pair : map) {
+    futures.emplace_back(async_safe(f, pair.first, pair.second));
+  }
+  for (auto &f : futures) {
+    f.get();
+  }
+}
+
+template <
+    template <typename...> class Map, typename KeyType, typename ValueType,
+    typename ApplyFunction,
+    typename ApplyType = typename details::key_value_apply_result<
+        ApplyFunction, KeyType, ValueType>::type,
+    typename std::enable_if<details::is_valid_key_value_apply_function<
+                                ApplyFunction, KeyType, ValueType>::value &&
+                                !std::is_same<void, ApplyType>::value,
+                            int>::type = 0>
+inline Grouped<KeyType, ApplyType>
+async_apply(const Map<KeyType, ValueType> &map, ApplyFunction &&f) {
+
+  std::map<KeyType, std::future<ApplyType>> futures;
+  for (const auto &pair : map) {
+    futures[pair.first] = async_safe(f, pair.first, pair.second);
+  }
+
+  Grouped<KeyType, ApplyType> output;
+  for (auto &pair : futures) {
+    output.emplace(pair.first, pair.second.get());
+  }
+  return output;
+}
+
+template <template <typename...> class Map, typename KeyType,
+          typename ValueType, typename ApplyFunction,
+          typename ApplyType = typename details::value_only_apply_result<
+              ApplyFunction, ValueType>::type,
+          typename std::enable_if<details::is_valid_value_only_apply_function<
+                                      ApplyFunction, ValueType>::value &&
+                                      !std::is_same<void, ApplyType>::value,
+                                  int>::type = 0>
+inline Grouped<KeyType, ApplyType>
+async_apply(const Map<KeyType, ValueType> &map, ApplyFunction &&f) {
+
+  std::map<KeyType, std::future<ApplyType>> futures;
+  for (const auto &pair : map) {
+    futures[pair.first] = async_safe(f, pair.second);
+  }
+
+  Grouped<KeyType, ApplyType> output;
+  for (auto &pair : futures) {
+    output.emplace(pair.first, pair.second.get());
+  }
+  return output;
+}
+
+template <template <typename...> class Map, typename KeyType,
+          typename ValueType, typename ApplyFunction,
+          typename ApplyType = typename details::value_only_apply_result<
+              ApplyFunction, ValueType>::type,
+          typename std::enable_if<details::is_valid_value_only_apply_function<
+                                      ApplyFunction, ValueType>::value &&
+                                      std::is_same<void, ApplyType>::value,
+                                  int>::type = 0>
+inline void async_apply(const Map<KeyType, ValueType> &map, ApplyFunction &&f) {
+  std::vector<std::future<void>> futures;
+  for (const auto &pair : map) {
+    futures.emplace_back(async_safe(f, pair.second));
+  }
+  for (auto &f : futures) {
+    f.get();
+  }
+}
+
+} // namespace albatross
+
+#endif /* INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_ */
diff --git a/include/albatross/src/indexing/group_by.hpp b/include/albatross/src/indexing/group_by.hpp
index 313b87c0..123345f0 100644
--- a/include/albatross/src/indexing/group_by.hpp
+++ b/include/albatross/src/indexing/group_by.hpp
@@ -115,6 +115,10 @@ template <typename KeyType, typename ValueType> class GroupedBase {
     return albatross::apply(map_, std::forward<ApplyFunction>(f));
   }
 
+  template <typename ApplyFunction> auto async_apply(ApplyFunction &&f) const {
+    return albatross::async_apply(map_, std::forward<ApplyFunction>(f));
+  }
+
 protected:
   std::map<KeyType, ValueType> map_;
 };
@@ -188,20 +192,13 @@ class Grouped<KeyType, GroupIndices>
   using Base = GroupedBase<KeyType, GroupIndices>;
   using Base::Base;
 
-  template <typename ApplyFunction,
-            typename ApplyType = typename details::key_value_apply_result<
-                ApplyFunction, KeyType, GroupIndices>::type,
-            typename std::enable_if<
-                details::is_valid_index_apply_function<ApplyFunction, KeyType,
-                                                       GroupIndices>::value &&
-                    !std::is_same<void, ApplyType>::value,
-                int>::type = 0>
-  auto index_apply(const ApplyFunction &f) const {
-    Grouped<KeyType, ApplyType> output;
-    for (const auto &pair : this->map_) {
-      output.emplace(pair.first, f(pair.first, pair.second));
-    }
-    return output;
+  template <typename ApplyFunction> auto index_apply(ApplyFunction &&f) const {
+    return apply(this->map_, std::forward<ApplyFunction>(f));
+  }
+
+  template <typename ApplyFunction>
+  auto async_index_apply(ApplyFunction &&f) const {
+    return async_apply(this->map_, std::forward<ApplyFunction>(f));
   }
 };
 
@@ -401,8 +398,12 @@ template <typename Derived> class GroupByBase {
 
   std::size_t size() const { return indexers().size(); }
 
-  template <typename ApplyFunction> auto apply(const ApplyFunction &f) const {
-    return groups().apply(f);
+  template <typename ApplyFunction> auto apply(ApplyFunction &&f) const {
+    return groups().apply(std::forward<ApplyFunction>(f));
+  }
+
+  template <typename ApplyFunction> auto async_apply(ApplyFunction &&f) const {
+    return groups().async_apply(std::forward<ApplyFunction>(f));
   }
 
   ValueType get_group(const KeyType &key) const {
@@ -415,38 +416,17 @@ template <typename Derived> class GroupByBase {
                           albatross::subset(parent_, first_indexer.second));
   }
 
-  template <typename ApplyFunction,
-            typename ApplyType = typename details::key_value_apply_result<
-                ApplyFunction, KeyType, GroupIndices>::type,
-            typename std::enable_if<
-                details::is_valid_index_apply_function<ApplyFunction, KeyType,
-                                                       GroupIndices>::value &&
-                    !std::is_same<void, ApplyType>::value,
-                int>::type = 0>
-  auto index_apply(const ApplyFunction &f) const {
-    Grouped<KeyType, ApplyType> output;
-    for (const auto &pair : indexers()) {
-      output.emplace(pair.first, f(pair.first, pair.second));
-    }
-    return output;
+  template <typename ApplyFunction> auto index_apply(ApplyFunction &&f) const {
+    return albatross::apply(indexers(), std::forward<ApplyFunction>(f));
   }
 
-  template <typename ApplyFunction,
-            typename ApplyType = typename details::key_value_apply_result<
-                ApplyFunction, KeyType, GroupIndices>::type,
-            typename std::enable_if<
-                details::is_valid_index_apply_function<ApplyFunction, KeyType,
-                                                       GroupIndices>::value &&
-                    std::is_same<void, ApplyType>::value,
-                int>::type = 0>
-  void index_apply(const ApplyFunction &f) const {
-    for (const auto &pair : indexers()) {
-      f(pair.first, pair.second);
-    }
+  template <typename ApplyFunction>
+  auto async_index_apply(ApplyFunction &&f) const {
+    return albatross::async_apply(indexers(), std::forward<ApplyFunction>(f));
   }
 
-  template <typename FilterFunction> auto filter(FilterFunction f) const {
-    return groups().filter(f);
+  template <typename FilterFunction> auto filter(FilterFunction &&f) const {
+    return groups().filter(std::forward<FilterFunction>(f));
   }
 
   Grouped<KeyType, std::size_t> counts() const {
diff --git a/include/albatross/src/utils/async_utils.hpp b/include/albatross/src/utils/async_utils.hpp
deleted file mode 100644
index 9f2fc40c..00000000
--- a/include/albatross/src/utils/async_utils.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2020 Swift Navigation Inc.
- * Contact: Swift Navigation <dev@swiftnav.com>
- *
- * This source is subject to the license found in the file 'LICENSE' which must
- * be distributed together with this source. All other rights reserved.
- *
- * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
- * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
- */
-
-#ifndef INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_
-#define INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_
-
-namespace albatross {
-
-// This method makes sure we don't accidentally call async with the
-// default mode which has some flaws:
-//
-// https://eli.thegreenplace.net/2016/the-promises-and-challenges-of-stdasync-task-based-parallelism-in-c11/
-template <typename F, typename... Ts>
-inline auto async_safe(F &&f, Ts &&... params) {
-  return std::async(std::launch::async, std::forward<F>(f),
-                    std::forward<Ts>(params)...);
-}
-
-template <typename ValueType, typename ApplyFunction,
-          typename ApplyType = typename details::value_only_apply_result<
-              ApplyFunction, ValueType>::type,
-          typename std::enable_if<details::is_valid_value_only_apply_function<
-                                      ApplyFunction, ValueType>::value &&
-                                      std::is_same<void, ApplyType>::value,
-                                  int>::type = 0>
-void async_apply(const std::vector<ValueType> &xs, const ApplyFunction &f) {
-  std::vector<std::future<void>> futures;
-  for (const auto &x : xs) {
-    futures.emplace_back(async_safe(f, x));
-  }
-  for (auto &f : futures) {
-    f.get();
-  }
-}
-
-template <typename ValueType, typename ApplyFunction,
-          typename ApplyType = typename details::value_only_apply_result<
-              ApplyFunction, ValueType>::type,
-          typename std::enable_if<details::is_valid_value_only_apply_function<
-                                      ApplyFunction, ValueType>::value &&
-                                      !std::is_same<void, ApplyType>::value,
-                                  int>::type = 0>
-auto async_apply(const std::vector<ValueType> &xs, const ApplyFunction &f) {
-  std::vector<std::future<ApplyType>> futures;
-  for (const auto &x : xs) {
-    futures.emplace_back(async_safe(f, x));
-  }
-
-  std::vector<ApplyType> output;
-  for (auto &f : futures) {
-    output.emplace_back(f.get());
-  }
-  return output;
-}
-
-} // namespace albatross
-
-#endif /* INCLUDE_ALBATROSS_SRC_UTILS_ASYNC_UTILS_HPP_ */
diff --git a/include/albatross/utils/AsyncUtils b/include/albatross/utils/AsyncUtils
deleted file mode 100644
index 436fdb63..00000000
--- a/include/albatross/utils/AsyncUtils
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (C) 2020 Swift Navigation Inc.
- * Contact: Swift Navigation <dev@swiftnav.com>
- *
- * This source is subject to the license found in the file 'LICENSE' which must
- * be distributed together with this source. All other rights reserved.
- *
- * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
- * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
- */
-
-#ifndef ALBATROSS_UTILS_ASYNC_UTILS_H
-#define ALBATROSS_UTILS_ASYNC_UTILS_H
-
-#include <future>
-
-#include "../src/utils/async_utils.hpp"
-
-#endif
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 53e9fade..5247cc8a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,6 +1,6 @@
 add_executable(albatross_unit_tests 
   test_apply.cc
-  test_async_utils.cc
+  test_async_apply.cc
   test_block_utils.cc
   test_call_trace.cc
   test_callers.cc
diff --git a/tests/test_async_utils.cc b/tests/test_async_apply.cc
similarity index 98%
rename from tests/test_async_utils.cc
rename to tests/test_async_apply.cc
index 0ea2843a..a8f9adf3 100644
--- a/tests/test_async_utils.cc
+++ b/tests/test_async_apply.cc
@@ -13,7 +13,6 @@
 #include <gtest/gtest.h>
 
 #include <albatross/Indexing>
-#include <albatross/utils/AsyncUtils>
 #include <albatross/utils/RandomUtils>
 
 #include <chrono>
diff --git a/tests/test_group_by.cc b/tests/test_group_by.cc
index a950f4ef..1b2e304e 100644
--- a/tests/test_group_by.cc
+++ b/tests/test_group_by.cc
@@ -283,6 +283,11 @@ TYPED_TEST_P(GroupByTester, test_groupby_apply_combine) {
 
   const auto combined = grouped.apply(only_keep_one).combine();
 
+  const auto async_combined = grouped.async_apply(only_keep_one).combine();
+
+  // Async an normal apply should match
+  EXPECT_EQ(combined, async_combined);
+
   // Same number of final combined elements as there are groups.
   EXPECT_EQ(grouped.size(), combined.size());
 }
@@ -296,7 +301,11 @@ TYPED_TEST_P(GroupByTester, test_groupby_apply_void) {
   const auto increment_count = [&](const auto &, const auto &) { ++count; };
 
   grouped.apply(increment_count);
+  EXPECT_EQ(grouped.size(), count);
 
+  // Again but with async
+  count = 0;
+  grouped.async_apply(increment_count);
   EXPECT_EQ(grouped.size(), count);
 }
 
@@ -305,11 +314,14 @@ TYPED_TEST_P(GroupByTester, test_groupby_apply_value_only) {
   const auto grouped = group_by(parent, this->test_case.get_grouper());
 
   std::size_t count = 0;
-
   const auto increment_count = [&](const auto &) { ++count; };
 
   grouped.apply(increment_count);
+  EXPECT_EQ(grouped.size(), count);
 
+  // Again but with async
+  count = 0;
+  grouped.async_apply(increment_count);
   EXPECT_EQ(grouped.size(), count);
 }
 
@@ -318,13 +330,16 @@ TYPED_TEST_P(GroupByTester, test_groupby_index_apply) {
   const auto grouped = group_by(parent, this->test_case.get_grouper());
 
   std::size_t count = 0;
-
   const auto increment_count = [&](const auto &, const GroupIndices &) {
     ++count;
   };
 
   grouped.index_apply(increment_count);
+  EXPECT_EQ(grouped.size(), count);
 
+  // Again but with async
+  count = 0;
+  grouped.async_index_apply(increment_count);
   EXPECT_EQ(grouped.size(), count);
 }