diff --git a/BUILD.gn b/BUILD.gn
index 0a0b5f2..6379134 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -53,6 +53,7 @@
     "$dir_pigweed/docs",
     "$dir_pw_base64",
     "$dir_pw_checksum",
+    "$dir_pw_kvs",
     "$dir_pw_polyfill",
     "$dir_pw_preprocessor",
     "$dir_pw_protobuf",
@@ -70,6 +71,7 @@
   group_deps = [
     "$dir_pw_base64:tests",
     "$dir_pw_checksum:tests",
+    "$dir_pw_kvs:tests",
     "$dir_pw_log:tests",
     "$dir_pw_polyfill:tests",
     "$dir_pw_preprocessor:tests",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b7b5d46..d8ed777 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,6 +24,7 @@
 add_subdirectory(pw_cpu_exception_armv7m)
 add_subdirectory(pw_dumb_io)
 add_subdirectory(pw_dumb_io_stdio)
+add_subdirectory(pw_kvs)
 add_subdirectory(pw_log)
 add_subdirectory(pw_log_basic)
 add_subdirectory(pw_polyfill)
diff --git a/modules.gni b/modules.gni
index d122bae..41fe5cf 100644
--- a/modules.gni
+++ b/modules.gni
@@ -29,6 +29,7 @@
 dir_pw_dumb_io_baremetal_stm32f429 =
     "$dir_pigweed/pw_dumb_io_baremetal_stm32f429"
 dir_pw_dumb_io_stdio = "$dir_pigweed/pw_dumb_io_stdio"
+dir_pw_kvs = "$dir_pigweed/pw_kvs"
 dir_pw_log = "$dir_pigweed/pw_log"
 dir_pw_log_basic = "$dir_pigweed/pw_log_basic"
 dir_pw_module = "$dir_pigweed/pw_module"
diff --git a/pw_kvs/BUILD b/pw_kvs/BUILD
new file mode 100644
index 0000000..b646357
--- /dev/null
+++ b/pw_kvs/BUILD
@@ -0,0 +1,66 @@
+# Copyright 2020 The Pigweed Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+load(
+    "//pw_build:pigweed.bzl",
+    "pw_cc_library",
+    "pw_cc_test",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # Apache License 2.0
+
+pw_cc_library(
+    name = "pw_kvs",
+    srcs = [
+        "flash.cc",
+        "key_value_store.cc",
+    ],
+    hdrs = [
+        "public/pw_kvs/assert.h",
+        "public/pw_kvs/flash.h",
+        "public/pw_kvs/flash_memory.h",
+        "public/pw_kvs/in_memory_fake_flash.h",
+        "public/pw_kvs/key_value_store.h",
+        "public/pw_kvs/partition_table_entry.h",
+    ],
+    includes = ["public"],
+    deps = [
+        "//pw_checksum",
+        "//pw_log",
+        "//pw_status",
+        "//pw_string",
+    ],
+)
+
+pw_cc_test(
+    name = "key_value_store_test",
+    srcs = ["key_value_store_test.cc"],
+    deps = [
+        ":pw_kvs",
+        "//pw_checksum",
+        "//pw_log",
+    ],
+)
+
+pw_cc_test(
+    name = "key_value_store_sub_sector_test",
+    srcs = ["key_value_store_sub_sector_test.cc"],
+    deps = [
+        ":pw_kvs",
+        "//pw_checksum",
+        "//pw_log",
+    ],
+)
diff --git a/pw_kvs/BUILD.gn b/pw_kvs/BUILD.gn
new file mode 100644
index 0000000..0c59dd1
--- /dev/null
+++ b/pw_kvs/BUILD.gn
@@ -0,0 +1,80 @@
+# Copyright 2020 The Pigweed Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+import("$dir_pw_docgen/docs.gni")
+import("$dir_pw_unit_test/test.gni")
+
+config("default_config") {
+  include_dirs = [ "public" ]
+}
+
+source_set("pw_kvs") {
+  public_configs = [ ":default_config" ]
+  public = [
+    "public/pw_kvs/assert.h",
+    "public/pw_kvs/flash.h",
+    "public/pw_kvs/flash_memory.h",
+    "public/pw_kvs/in_memory_fake_flash.h",
+    "public/pw_kvs/key_value_store.h",
+    "public/pw_kvs/partition_table_entry.h",
+  ]
+  sources = [
+    "flash.cc",
+    "key_value_store.cc",
+  ]
+  sources += public
+  public_deps = [
+    "$dir_pw_status",
+  ]
+  deps = [
+    dir_pw_checksum,
+    dir_pw_log,
+    dir_pw_string,
+  ]
+}
+
+pw_test_group("tests") {
+  tests = [
+    ":key_value_store_test",
+    ":key_value_store_sub_sector_test",
+  ]
+}
+
+pw_test("key_value_store_test") {
+  deps = [
+    ":pw_kvs",
+    dir_pw_checksum,
+    dir_pw_log,
+  ]
+  sources = [
+    "key_value_store_test.cc",
+  ]
+}
+
+pw_test("key_value_store_sub_sector_test") {
+  deps = [
+    ":pw_kvs",
+    dir_pw_checksum,
+    dir_pw_log,
+  ]
+  sources = [
+    "key_value_store_sub_sector_test.cc",
+  ]
+}
+
+pw_doc_group("docs") {
+  sources = [
+    "docs.rst",
+  ]
+}
diff --git a/pw_kvs/CMakeLists.txt b/pw_kvs/CMakeLists.txt
new file mode 100644
index 0000000..2d998bb
--- /dev/null
+++ b/pw_kvs/CMakeLists.txt
@@ -0,0 +1,22 @@
+# Copyright 2020 The Pigweed Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+pw_auto_add_simple_module(pw_kvs
+  PUBLIC_DEPS
+    pw_status
+  PRIVATE_DEPS
+    pw_checksum
+    pw_log
+    pw_string
+)
diff --git a/pw_kvs/flash.cc b/pw_kvs/flash.cc
index bcc695f..dad5fab 100644
--- a/pw_kvs/flash.cc
+++ b/pw_kvs/flash.cc
@@ -12,29 +12,41 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-#include "pw_kvs/util/flash.h"
+#include "pw_kvs/flash.h"
 
-#include "pw_kvs/config.h"
+#include <cstring>
 
-namespace pw {
+namespace pw::kvs {
+namespace cfg {
+
+// Configure the maximum supported alignment for the flash utility functions.
+constexpr size_t kFlashUtilMaxAlignmentBytes = 16;
+
+}  // namespace cfg
 
 Status PaddedWrite(FlashPartition* partition,
                    FlashPartition::Address address,
                    const uint8_t* buffer,
                    uint16_t size) {
-  RETURN_STATUS_IF(
-      address % partition->GetAlignmentBytes() ||
-          partition->GetAlignmentBytes() > cfg::kFlashUtilMaxAlignmentBytes,
-      Status::INVALID_ARGUMENT);
+  if (address % partition->GetAlignmentBytes() ||
+      partition->GetAlignmentBytes() > cfg::kFlashUtilMaxAlignmentBytes) {
+    return Status::INVALID_ARGUMENT;
+  }
   uint8_t alignment_buffer[cfg::kFlashUtilMaxAlignmentBytes] = {0};
   uint16_t aligned_bytes = size - size % partition->GetAlignmentBytes();
-  RETURN_IF_ERROR(partition->Write(address, buffer, aligned_bytes));
+  if (Status status = partition->Write(address, buffer, aligned_bytes);
+      !status.ok()) {
+    return status;
+  }
   uint16_t remaining_bytes = size - aligned_bytes;
   if (remaining_bytes > 0) {
-    memcpy(alignment_buffer, &buffer[aligned_bytes], remaining_bytes);
-    RETURN_IF_ERROR(partition->Write(address + aligned_bytes,
-                                     alignment_buffer,
-                                     partition->GetAlignmentBytes()));
+    std::memcpy(alignment_buffer, &buffer[aligned_bytes], remaining_bytes);
+    if (Status status = partition->Write(address + aligned_bytes,
+                                         alignment_buffer,
+                                         partition->GetAlignmentBytes());
+        !status.ok()) {
+      return status;
+    }
   }
   return Status::OK;
 }
@@ -43,21 +55,27 @@
                      uint8_t* buffer,
                      FlashPartition::Address address,
                      uint16_t size) {
-  RETURN_STATUS_IF(
-      address % partition->GetAlignmentBytes() ||
-          partition->GetAlignmentBytes() > cfg::kFlashUtilMaxAlignmentBytes,
-      Status::INVALID_ARGUMENT);
+  if (address % partition->GetAlignmentBytes() ||
+      partition->GetAlignmentBytes() > cfg::kFlashUtilMaxAlignmentBytes) {
+    return Status::INVALID_ARGUMENT;
+  }
   uint16_t aligned_bytes = size - size % partition->GetAlignmentBytes();
-  RETURN_IF_ERROR(partition->Read(buffer, address, aligned_bytes));
+  if (Status status = partition->Read(buffer, address, aligned_bytes);
+      !status.ok()) {
+    return status;
+  }
   uint16_t remaining_bytes = size - aligned_bytes;
   if (remaining_bytes > 0) {
     uint8_t alignment_buffer[cfg::kFlashUtilMaxAlignmentBytes];
-    RETURN_IF_ERROR(partition->Read(alignment_buffer,
-                                    address + aligned_bytes,
-                                    partition->GetAlignmentBytes()));
+    if (Status status = partition->Read(alignment_buffer,
+                                        address + aligned_bytes,
+                                        partition->GetAlignmentBytes());
+        !status.ok()) {
+      return status;
+    }
     memcpy(&buffer[aligned_bytes], alignment_buffer, remaining_bytes);
   }
   return Status::OK;
 }
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index ce21740..b1a6505 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -46,19 +46,16 @@
 
 #include <cstring>
 
-#include "pw_kvs/os/mutex.h"
-#include "pw_kvs/util/ccitt_crc16.h"
-#include "pw_kvs/util/constexpr.h"
-#include "pw_kvs/util/flash.h"
+#include "pw_checksum/ccitt_crc16.h"
+#include "pw_kvs/flash.h"
+#include "pw_log/log.h"
+#include "pw_string/string_builder.h"
+#include "pw_string/util.h"
 
-namespace pw {
-
-// Declare static constexpr variables so it can be used for pass-by-reference
-// functions.
-constexpr uint16_t KeyValueStore::kSectorReadyValue;
+namespace pw::kvs {
 
 Status KeyValueStore::Enable() {
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   if (enabled_) {
     return Status::OK;
   }
@@ -71,9 +68,11 @@
   alignment_bytes_ = partition_.GetAlignmentBytes();
   DCHECK(alignment_bytes_ <= kMaxAlignmentBytes);
 
-  LOG_WARN_IF(partition_.GetSectorCount() > kSectorCountMax,
-              "Partition is larger then KVS max sector count, not all space "
-              "will be used.");
+  if (partition_.GetSectorCount() > kSectorCountMax) {
+    PW_LOG_WARN(
+        "Partition is larger then KVS max sector count, "
+        "not all space will be used.");
+  }
   // Load map and setup sectors if needed (first word isn't kSectorReadyValue).
   next_sector_clean_order_ = 0;
   for (SectorIndex i = 0; i < SectorCount(); i++) {
@@ -82,45 +81,60 @@
     // may give random values. It's important to make sure that data is not
     // erased before trying to see if there is a token match.
     bool is_sector_meta_erased;
-    RETURN_IF_ERROR(partition_.IsChunkErased(
-        SectorIndexToAddress(i),
-        RoundUpForAlignment(sizeof(sector_header_meta)),
-        &is_sector_meta_erased));
-    RETURN_IF_ERROR(
-        UnalignedRead(&partition_,
-                      reinterpret_cast<uint8_t*>(&sector_header_meta),
-                      SectorIndexToAddress(i),
-                      sizeof(sector_header_meta)));
+    if (Status status = partition_.IsChunkErased(
+            SectorIndexToAddress(i),
+            RoundUpForAlignment(sizeof(sector_header_meta)),
+            &is_sector_meta_erased);
+        !status.ok()) {
+      return status;
+    };
+    if (Status status =
+            UnalignedRead(&partition_,
+                          reinterpret_cast<uint8_t*>(&sector_header_meta),
+                          SectorIndexToAddress(i),
+                          sizeof(sector_header_meta));
+        !status.ok()) {
+      return status;
+    }
 
     constexpr int kVersion3 = 3;  // Version 3 only cleans 1 sector at a time.
     constexpr int kVersion2 = 2;  // Version 2 is always 1 byte aligned.
     if (is_sector_meta_erased ||
         sector_header_meta.synchronize_token != kSectorReadyValue) {
       // Sector needs to be setup
-      RETURN_IF_ERROR(ResetSector(i));
+      if (Status status = ResetSector(i); !status.ok()) {
+        return status;
+      }
       continue;
     } else if (sector_header_meta.version != kVersion &&
                sector_header_meta.version != kVersion3 &&  // Allow version 3
                sector_header_meta.version != kVersion2) {  // Allow version 2
-      LOG(ERROR) << "Unsupported KVS version in sector: " << i;
+      PW_LOG_ERROR("Unsupported KVS version in sector: %u",
+                   static_cast<unsigned>(i));
       return Status::FAILED_PRECONDITION;
     }
     uint32_t sector_header_cleaning_offset =
         RoundUpForAlignment(sizeof(KvsSectorHeaderMeta));
 
     bool clean_not_pending;
-    RETURN_IF_ERROR(partition_.IsChunkErased(
-        SectorIndexToAddress(i) + sector_header_cleaning_offset,
-        RoundUpForAlignment(sizeof(KvsSectorHeaderCleaning)),
-        &clean_not_pending));
+    if (Status status = partition_.IsChunkErased(
+            SectorIndexToAddress(i) + sector_header_cleaning_offset,
+            RoundUpForAlignment(sizeof(KvsSectorHeaderCleaning)),
+            &clean_not_pending);
+        !status.ok()) {
+      return status;
+    }
 
     if (!clean_not_pending) {
       // Sector is marked for cleaning, read the sector_clean_order
-      RETURN_IF_ERROR(
-          UnalignedRead(&partition_,
-                        reinterpret_cast<uint8_t*>(&sector_clean_order_[i]),
-                        SectorIndexToAddress(i) + sector_header_cleaning_offset,
-                        sizeof(KvsSectorHeaderCleaning::sector_clean_order)));
+      if (Status status = UnalignedRead(
+              &partition_,
+              reinterpret_cast<uint8_t*>(&sector_clean_order_[i]),
+              SectorIndexToAddress(i) + sector_header_cleaning_offset,
+              sizeof(KvsSectorHeaderCleaning::sector_clean_order));
+          !status.ok()) {
+        return status;
+      }
       next_sector_clean_order_ =
           std::max(sector_clean_order_[i] + 1, next_sector_clean_order_);
     } else {
@@ -133,9 +147,10 @@
     }
     if (sector_header_meta.alignment_bytes != alignment_bytes_) {
       // NOTE: For now all sectors must have same alignment.
-      LOG(ERROR) << "Sector " << i << " has unexpected alignment "
-                 << alignment_bytes_
-                 << " != " << sector_header_meta.alignment_bytes;
+      PW_LOG_ERROR("Sector %u has unexpected alignment %u != %u",
+                   unsigned(i),
+                   unsigned(alignment_bytes_),
+                   unsigned(sector_header_meta.alignment_bytes));
       return Status::FAILED_PRECONDITION;
     }
 
@@ -154,15 +169,23 @@
       // Because underlying flash can be encrypted + erased, trying to readback
       // may give random values. It's important to make sure that data is not
       // erased before trying to see if there is a token match.
-      RETURN_IF_ERROR(partition_.IsChunkErased(
-          address, RoundUpForAlignment(sizeof(header)), &is_kvs_header_erased));
-      RETURN_IF_ERROR(UnalignedRead(&partition_,
-                                    reinterpret_cast<uint8_t*>(&header),
-                                    address,
-                                    sizeof(header)));
+      if (Status status =
+              partition_.IsChunkErased(address,
+                                       RoundUpForAlignment(sizeof(header)),
+                                       &is_kvs_header_erased);
+          !status.ok()) {
+        return status;
+      }
+      if (Status status = UnalignedRead(&partition_,
+                                        reinterpret_cast<uint8_t*>(&header),
+                                        address,
+                                        sizeof(header));
+          !status.ok()) {
+        return status;
+      }
       if (is_kvs_header_erased || header.synchronize_token != kChunkSyncValue) {
         if (!is_kvs_header_erased) {
-          LOG_ERROR("Next sync_token is not clear!");
+          PW_LOG_ERROR("Next sync_token is not clear!");
           // TODO: handle this?
         }
         break;  // End of elements in sector
@@ -174,18 +197,24 @@
                     "nul-terminator.");
 
       // Read key and add to map
-      RETURN_IF_ERROR(
-          UnalignedRead(&partition_,
-                        reinterpret_cast<uint8_t*>(&temp_key_buffer_),
-                        address + RoundUpForAlignment(sizeof(header)),
-                        header.key_len));
+      if (Status status =
+              UnalignedRead(&partition_,
+                            reinterpret_cast<uint8_t*>(&temp_key_buffer_),
+                            address + RoundUpForAlignment(sizeof(header)),
+                            header.key_len);
+          !status.ok()) {
+        return status;
+      }
       temp_key_buffer_[header.key_len] = '\0';
       bool is_erased = header.flags & kFlagsIsErasedMask;
 
       KeyIndex index = FindKeyInMap(temp_key_buffer_);
       if (index == kListCapacityMax) {
-        RETURN_IF_ERROR(AppendToMap(
-            temp_key_buffer_, address, header.chunk_len, is_erased));
+        if (Status status = AppendToMap(
+                temp_key_buffer_, address, header.chunk_len, is_erased);
+            !status.ok()) {
+          return status;
+        }
       } else if (sector_clean_order_[i] >=
                  sector_clean_order_[AddressToSectorIndex(
                      key_map_[index].address)]) {
@@ -202,8 +231,11 @@
         clean_not_pending ? partition_.GetSectorSizeBytes() - offset : 0;
   }
 
-  LOG_IF_ERROR(EnforceFreeSector())
-      << "Failed to force clean at boot, no free sectors available!";
+  if (Status status = EnforceFreeSector(); !status.ok()) {
+    PW_LOG_ERROR(
+        "%s: Failed to force clean at boot, no free sectors available!",
+        status.str());
+  }
   enabled_ = true;
   return Status::OK;
 }
@@ -218,17 +250,17 @@
     return Status::INVALID_ARGUMENT;
   }
 
-  size_t key_len = util::StringLength(key, kChunkKeyLengthMax + 1u);
+  size_t key_len = string::Length(key, kChunkKeyLengthMax + 1u);
   if (key_len == 0 || key_len > kChunkKeyLengthMax) {
     return Status::INVALID_ARGUMENT;
   }
 
   // TODO: Support unaligned offset reads.
   if (offset % alignment_bytes_ != 0) {
-    LOG_ERROR("Currently unaligned offsets are not supported");
+    PW_LOG_ERROR("Currently unaligned offsets are not supported");
     return Status::INVALID_ARGUMENT;
   }
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   if (!enabled_) {
     return Status::FAILED_PRECONDITION;
   }
@@ -239,35 +271,41 @@
   }
   KvsHeader header;
   // TODO: Could cache the CRC and avoid reading the header.
-  RETURN_IF_ERROR(UnalignedRead(&partition_,
-                                reinterpret_cast<uint8_t*>(&header),
-                                key_map_[key_index].address,
-                                sizeof(header)));
+  if (Status status = UnalignedRead(&partition_,
+                                    reinterpret_cast<uint8_t*>(&header),
+                                    key_map_[key_index].address,
+                                    sizeof(header));
+      !status.ok()) {
+    return status;
+  }
   if (kChunkSyncValue != header.synchronize_token) {
     return Status::DATA_LOSS;
   }
   if (size + offset > header.chunk_len) {
-    LOG_ERROR("Out of bounds read: offset(%u) + size(%u) > data_size(%u)",
-              offset,
-              size,
-              header.chunk_len);
+    PW_LOG_ERROR("Out of bounds read: offset(%u) + size(%u) > data_size(%u)",
+                 offset,
+                 size,
+                 header.chunk_len);
     return Status::INVALID_ARGUMENT;
   }
-  RETURN_IF_ERROR(UnalignedRead(
-      &partition_,
-      value,
-      key_map_[key_index].address + RoundUpForAlignment(sizeof(KvsHeader)) +
-          RoundUpForAlignment(header.key_len) + offset,
-      size));
+  if (Status status = UnalignedRead(
+          &partition_,
+          value,
+          key_map_[key_index].address + RoundUpForAlignment(sizeof(KvsHeader)) +
+              RoundUpForAlignment(header.key_len) + offset,
+          size);
+      !status.ok()) {
+    return status;
+  }
 
   // Verify CRC only when full packet was read.
   if (offset == 0 && size == header.chunk_len) {
     uint16_t crc = CalculateCrc(key, key_len, value, size);
     if (crc != header.crc) {
-      LOG_ERROR("KVS CRC does not match for key=%s [expected %u, found %u]",
-                key,
-                header.crc,
-                crc);
+      PW_LOG_ERROR("KVS CRC does not match for key=%s [expected %u, found %u]",
+                   key,
+                   header.crc,
+                   crc);
       return Status::DATA_LOSS;
     }
   }
@@ -278,9 +316,8 @@
                                      uint16_t key_size,
                                      const uint8_t* value,
                                      uint16_t value_size) const {
-  CcittCrc16 crc;
-  crc.AppendBytes(ConstBuffer(reinterpret_cast<const uint8_t*>(key), key_size));
-  return crc.AppendBytes(ConstBuffer(value, value_size));
+  uint16_t crc = checksum::CcittCrc16(as_bytes(span(key, key_size)));
+  return checksum::CcittCrc16(as_bytes(span(value, value_size)), crc);
 }
 
 Status KeyValueStore::CalculateCrcFromValueAddress(
@@ -289,15 +326,17 @@
     FlashPartition::Address value_address,
     uint16_t value_size,
     uint16_t* crc_ret) {
-  CcittCrc16 crc;
-  crc.AppendBytes(ConstBuffer(reinterpret_cast<const uint8_t*>(key), key_size));
+  uint16_t crc = checksum::CcittCrc16(as_bytes(span(key, key_size)));
   for (size_t i = 0; i < value_size; i += TempBufferAlignedSize()) {
     auto read_size = std::min(value_size - i, TempBufferAlignedSize());
-    RETURN_IF_ERROR(
-        UnalignedRead(&partition_, temp_buffer_, value_address + i, read_size));
-    crc.AppendBytes(ConstBuffer(temp_buffer_, read_size));
+    if (Status status = UnalignedRead(
+            &partition_, temp_buffer_, value_address + i, read_size);
+        !status.ok()) {
+      return status;
+    }
+    crc = checksum::CcittCrc16(as_bytes(span(temp_buffer_, read_size)));
   }
-  *crc_ret = crc.CurrentValue();
+  *crc_ret = crc;
   return Status::OK;
 }
 
@@ -309,13 +348,13 @@
     return Status::INVALID_ARGUMENT;
   }
 
-  size_t key_len = util::StringLength(key, (kChunkKeyLengthMax + 1u));
+  size_t key_len = string::Length(key, kChunkKeyLengthMax + 1u);
   if (key_len == 0 || key_len > kChunkKeyLengthMax ||
       size > kChunkValueLengthMax) {
     return Status::INVALID_ARGUMENT;
   }
 
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   if (!enabled_) {
     return Status::FAILED_PRECONDITION;
   }
@@ -333,7 +372,9 @@
   // Check if this would use the last empty sector on KVS with multiple sectors
   if (SectorCount() > 1 && IsInLastFreeSector(address)) {
     // Forcing a full garbage collect to free more sectors.
-    RETURN_IF_ERROR(FullGarbageCollect());
+    if (Status status = FullGarbageCollect(); !status.ok()) {
+      return status;
+    }
     address = FindSpace(ChunkSize(key_len, size));
     if (address == kSectorInvalid || IsInLastFreeSector(address)) {
       // Couldn't find space, KVS is full.
@@ -341,8 +382,12 @@
     }
   }
 
-  RETURN_IF_ERROR(WriteKeyValue(address, key, value, size));
-  RETURN_IF_ERROR(AppendToMap(key, address, size));
+  if (Status status = WriteKeyValue(address, key, value, size); !status.ok()) {
+    return status;
+  }
+  if (Status status = AppendToMap(key, address, size); !status.ok()) {
+    return status;
+  }
 
   return Status::OK;
 }
@@ -362,7 +407,9 @@
     if (clean_pending_sectors ==
         (sector_clean_order_[sector] != kSectorCleanNotPending)) {
       if (!clean_pending_sectors) {
-        RETURN_IF_ERROR(MarkSectorForClean(sector));
+        if (Status status = MarkSectorForClean(sector); !status.ok()) {
+          return status;
+        }
       }
       Status status = CleanSector(sector);
       if (!status.ok() && status != Status::RESOURCE_EXHAUSTED) {
@@ -380,22 +427,31 @@
   if (SectorCount() == 1 || HasEmptySector()) {
     return Status::OK;
   }
-  LOG_INFO("KVS garbage collecting to get a free sector");
-  RETURN_IF_ERROR(GarbageCollectImpl(true /*clean_pending_sectors*/,
-                                     true /*exit_when_have_free_sector*/));
+  PW_LOG_INFO("KVS garbage collecting to get a free sector");
+  if (Status status = GarbageCollectImpl(true /*clean_pending_sectors*/,
+                                         true /*exit_when_have_free_sector*/);
+      !status.ok()) {
+    return status;
+  }
   if (HasEmptySector()) {
     return Status::OK;
   }
-  LOG_INFO("KVS: trying to clean non-pending sectors for more space");
-  RETURN_IF_ERROR(GarbageCollectImpl(false /*clean_pending_sectors*/,
-                                     true /*exit_when_have_free_sector*/));
+  PW_LOG_INFO("KVS: trying to clean non-pending sectors for more space");
+  if (Status status = GarbageCollectImpl(false /*clean_pending_sectors*/,
+                                         true /*exit_when_have_free_sector*/);
+      !status.ok()) {
+    return status;
+  }
   return HaveEmptySectorImpl() ? Status::OK : Status::RESOURCE_EXHAUSTED;
 }
 
 Status KeyValueStore::FullGarbageCollect() {
-  LOG_INFO("KVS: Full garbage collecting to try to free space");
-  RETURN_IF_ERROR(GarbageCollectImpl(true /*clean_pending_sectors*/,
-                                     false /*exit_when_have_free_sector*/));
+  PW_LOG_INFO("KVS: Full garbage collecting to try to free space");
+  if (Status status = GarbageCollectImpl(true /*clean_pending_sectors*/,
+                                         false /*exit_when_have_free_sector*/);
+      !status.ok()) {
+    return status;
+  }
   return GarbageCollectImpl(false /*clean_pending_sectors*/,
                             false /*exit_when_have_free_sector*/);
 }
@@ -410,8 +466,10 @@
   }
 
   size_t key_length =
-      util::StringLength(key_map_[key_index].key, (kChunkKeyLengthMax + 1u));
-  RETURN_STATUS_IF(key_length > kChunkKeyLengthMax, Status::INTERNAL);
+      string::Length(key_map_[key_index].key, kChunkKeyLengthMax + 1u);
+  if (key_length > kChunkKeyLengthMax) {
+    return Status::INTERNAL;
+  }
 
   uint32_t space_required = ChunkSize(key_length, size);
   SectorIndex sector = AddressToSectorIndex(key_map_[key_index].address);
@@ -424,14 +482,19 @@
               sector_space_remaining;
   } else {
     // No space in current sector, mark sector for clean and use another sector.
-    RETURN_IF_ERROR(MarkSectorForClean(sector));
+    if (Status status = MarkSectorForClean(sector); !status.ok()) {
+      return status;
+    }
     address = FindSpace(ChunkSize(key_length, size));
   }
   if (address == kSectorInvalid) {
     return Status::RESOURCE_EXHAUSTED;
   }
-  RETURN_IF_ERROR(
-      WriteKeyValue(address, key_map_[key_index].key, value, size, is_erased));
+  if (Status status = WriteKeyValue(
+          address, key_map_[key_index].key, value, size, is_erased);
+      !status.ok()) {
+    return status;
+  }
   UpdateMap(key_index, address, size, is_erased);
 
   return EnforceFreeSector();
@@ -451,7 +514,7 @@
                 key_map_[index].address,
                 sizeof(header));
   uint8_t key_len =
-      util::StringLength(key_map_[index].key, (kChunkKeyLengthMax + 1u));
+      string::Length(key_map_[index].key, kChunkKeyLengthMax + 1u);
   if (key_len > kChunkKeyLengthMax) {
     return false;
   }
@@ -477,7 +540,7 @@
     auto status =
         UnalignedRead(&partition_, temp_buffer_, address + i, read_size);
     if (!status.ok()) {
-      LOG(ERROR) << "Failed to read chunk: " << status;
+      PW_LOG_ERROR("Failed to read chunk: %s", status.str());
       return false;
     }
     if (memcmp(value + i, temp_buffer_, read_size) != 0) {
@@ -492,11 +555,11 @@
     return Status::INVALID_ARGUMENT;
   }
 
-  size_t key_len = util::StringLength(key, (kChunkKeyLengthMax + 1u));
+  size_t key_len = string::Length(key, kChunkKeyLengthMax + 1u);
   if (key_len == 0 || key_len > kChunkKeyLengthMax) {
     return Status::INVALID_ARGUMENT;
   }
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   if (!enabled_) {
     return Status::FAILED_PRECONDITION;
   }
@@ -525,10 +588,14 @@
     return status;
   }
 
-  RETURN_IF_ERROR(PaddedWrite(&partition_,
-                              SectorIndexToAddress(sector_index),
-                              reinterpret_cast<const uint8_t*>(&sector_header),
-                              sizeof(sector_header)));
+  if (Status status =
+          PaddedWrite(&partition_,
+                      SectorIndexToAddress(sector_index),
+                      reinterpret_cast<const uint8_t*>(&sector_header),
+                      sizeof(sector_header));
+      !status.ok()) {
+    return status;
+  }
 
   // Update space remaining
   sector_clean_order_[sector_index] = kSectorCleanNotPending;
@@ -541,8 +608,10 @@
                                     const uint8_t* value,
                                     uint16_t size,
                                     bool is_erased) {
-  uint16_t key_length = util::StringLength(key, (kChunkKeyLengthMax + 1u));
-  RETURN_STATUS_IF(key_length > kChunkKeyLengthMax, Status::INTERNAL);
+  uint16_t key_length = string::Length(key, kChunkKeyLengthMax + 1u);
+  if (key_length > kChunkKeyLengthMax) {
+    return Status::INTERNAL;
+  }
 
   constexpr uint16_t kFlagDefaultValue = 0;
   KvsHeader header = {
@@ -553,16 +622,26 @@
       .chunk_len = size};
 
   SectorIndex sector = AddressToSectorIndex(address);
-  RETURN_IF_ERROR(PaddedWrite(&partition_,
-                              address,
-                              reinterpret_cast<uint8_t*>(&header),
-                              sizeof(header)));
+  if (Status status = PaddedWrite(&partition_,
+                                  address,
+                                  reinterpret_cast<uint8_t*>(&header),
+                                  sizeof(header));
+      !status.ok()) {
+    return status;
+  }
   address += RoundUpForAlignment(sizeof(header));
-  RETURN_IF_ERROR(PaddedWrite(
-      &partition_, address, reinterpret_cast<const uint8_t*>(key), key_length));
+  if (Status status = PaddedWrite(&partition_,
+                                  address,
+                                  reinterpret_cast<const uint8_t*>(key),
+                                  key_length);
+      !status.ok()) {
+  }
   address += RoundUpForAlignment(key_length);
   if (size > 0) {
-    RETURN_IF_ERROR(PaddedWrite(&partition_, address, value, size));
+    if (Status status = PaddedWrite(&partition_, address, value, size);
+        !status.ok()) {
+      return status;
+    }
   }
   sector_space_remaining_[sector] -= ChunkSize(key_length, size);
   return Status::OK;
@@ -579,9 +658,16 @@
   for (size_t i = 0; i < size; i += TempBufferAlignedSize()) {
     size_t move_size = std::min(size - i, TempBufferAlignedSize());
     DCHECK_EQ(move_size % alignment_bytes_, 0);
-    RETURN_IF_ERROR(partition_.Read(temp_buffer_, src_address + i, move_size));
-    RETURN_IF_ERROR(
-        partition_.Write(dest_address + i, temp_buffer_, move_size));
+    if (Status status =
+            partition_.Read(temp_buffer_, src_address + i, move_size);
+        !status.ok()) {
+      return status;
+    }
+    if (Status status =
+            partition_.Write(dest_address + i, temp_buffer_, move_size);
+        !status.ok()) {
+      return status;
+    }
   }
   return Status::OK;
 }
@@ -594,12 +680,15 @@
   // Flag the sector as clean being active. This ensures we can handle losing
   // power while a clean is active.
   const KvsSectorHeaderCleaning kValue = {next_sector_clean_order_};
-  RETURN_IF_ERROR(
-      PaddedWrite(&partition_,
-                  SectorIndexToAddress(sector) +
-                      RoundUpForAlignment(sizeof(KvsSectorHeaderMeta)),
-                  reinterpret_cast<const uint8_t*>(&kValue),
-                  sizeof(kValue)));
+  if (Status status =
+          PaddedWrite(&partition_,
+                      SectorIndexToAddress(sector) +
+                          RoundUpForAlignment(sizeof(KvsSectorHeaderMeta)),
+                      reinterpret_cast<const uint8_t*>(&kValue),
+                      sizeof(kValue));
+      !status.ok()) {
+    return status;
+  }
   sector_space_remaining_[sector] = 0;
   sector_clean_order_[sector] = next_sector_clean_order_;
   next_sector_clean_order_++;
@@ -621,14 +710,17 @@
 
     if (i < map_size_ && sector == AddressToSectorIndex(key_map_[i].address)) {
       uint8_t key_len =
-          util::StringLength(key_map_[i].key, (kChunkKeyLengthMax + 1u));
+          string::Length(key_map_[i].key, kChunkKeyLengthMax + 1u);
       FlashPartition::Address address = key_map_[i].address;
       auto size = ChunkSize(key_len, key_map_[i].chunk_len);
       FlashPartition::Address move_address = FindSpace(size);
       if (move_address == kSectorInvalid) {
         return Status::RESOURCE_EXHAUSTED;
       }
-      RETURN_IF_ERROR(MoveChunk(move_address, address, size));
+      if (Status status = MoveChunk(move_address, address, size);
+          !status.ok()) {
+        return status;
+      }
       sector_space_remaining_[AddressToSectorIndex(move_address)] -= size;
       key_map_[i].address = move_address;  // Update map
     }
@@ -641,7 +733,7 @@
   if (all_sectors_have_been_cleaned == nullptr) {
     return Status::INVALID_ARGUMENT;
   }
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   bool have_cleaned_sector = false;
   for (SectorIndex sector = 0; sector < SectorCount(); sector++) {
     if (sector_clean_order_[sector] != kSectorCleanNotPending) {
@@ -649,7 +741,9 @@
         *all_sectors_have_been_cleaned = false;
         return Status::OK;
       }
-      RETURN_IF_ERROR(CleanSector(sector));
+      if (Status status = CleanSector(sector); !status.ok()) {
+        return status;
+      }
       have_cleaned_sector = true;
     }
   }
@@ -660,7 +754,9 @@
 Status KeyValueStore::CleanAllInternal() {
   for (SectorIndex sector = 0; sector < SectorCount(); sector++) {
     if (sector_clean_order_[sector] != kSectorCleanNotPending) {
-      RETURN_IF_ERROR(CleanSector(sector));
+      if (Status status = CleanSector(sector); !status.ok()) {
+        return status;
+      }
     }
   }
   return Status::OK;
@@ -703,11 +799,11 @@
     return Status::INVALID_ARGUMENT;
   }
 
-  size_t key_len = util::StringLength(key, (kChunkKeyLengthMax + 1u));
+  size_t key_len = string::Length(key, kChunkKeyLengthMax + 2u);
   if (key_len == 0 || key_len > kChunkKeyLengthMax) {
     return Status::INVALID_ARGUMENT;
   }
-  os::MutexLock lock(&lock_);
+  // TODO: LOCK MUTEX
   if (!enabled_) {
     return Status::FAILED_PRECONDITION;
   }
@@ -725,17 +821,17 @@
                                   uint16_t chunk_len,
                                   bool is_erased) {
   if (map_size_ >= kListCapacityMax) {
-    LOG_ERROR("Can't add: reached max supported keys %d", kListCapacityMax);
+    PW_LOG_ERROR("Can't add: reached max supported keys %d", kListCapacityMax);
     return Status::INTERNAL;
   }
 
   // Copy incoming key into map entry, ensuring size checks and nul-termination.
-  StringBuilder key_builder(key_map_[map_size_].key,
-                            sizeof(key_map_[map_size_].key));
+  StringBuilder key_builder(
+      span(key_map_[map_size_].key, sizeof(key_map_[map_size_].key)));
   key_builder.append(key);
 
   if (!key_builder.status().ok()) {
-    LOG_ERROR("Can't add: got invalid key: %s!", key_builder.status().str());
+    PW_LOG_ERROR("Can't add: got invalid key: %s!", key_builder.status().str());
     return Status::INTERNAL;
   }
 
@@ -802,4 +898,4 @@
   return 0;
 }
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/key_value_store_sub_sector_test.cc b/pw_kvs/key_value_store_sub_sector_test.cc
index ff908f5..0e13167 100644
--- a/pw_kvs/key_value_store_sub_sector_test.cc
+++ b/pw_kvs/key_value_store_sub_sector_test.cc
@@ -12,34 +12,29 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-#include "pw_kvs/key_value_store.h"
-
+#include "gtest/gtest.h"
 #include "pw_kvs/assert.h"
-#include "pw_kvs/devices/flash_memory.h"
-#include "pw_kvs/platform/board.h"
-#include "pw_kvs/status.h"
-#include "pw_kvs/test/fixture.h"
-#include "pw_kvs/test/framework.h"
-#include "pw_kvs/test/status_macros.h"
+#include "pw_kvs/flash_memory.h"
+#include "pw_kvs/key_value_store.h"
+#include "pw_status/status.h"
+
+#define USE_MEMORY_BUFFER 1
 
 #if USE_MEMORY_BUFFER
-#include "pw_kvs/test/fakes/in_memory_fake_flash.h"
+#include "pw_kvs/in_memory_fake_flash.h"
 #endif  // USE_MEMORY_BUFFER
 
-namespace pw {
+namespace pw::kvs {
 namespace {
 
 #if USE_MEMORY_BUFFER
 InMemoryFakeFlash<1024, 4> test_flash(8);  // 4 x 1k sectors, 8 byte alignment
 FlashPartition test_partition(&test_flash, 0, test_flash.GetSectorCount());
-// Test KVS against FlashSubSector
-FlashMemorySubSector test_subsector_flash(&test_flash,
-                                          0,
-                                          128);  // Expose less than a sector.
-#else   // Device test
-FlashPartition& test_partition = Board::Instance().FlashExternalTestPartition();
-FlashMemorySubSector& test_subsector_flash =
-    Board::Instance().FlashMemorySubSectorTestChunk();
+// Test KVS against FlashSubSector.  Expose less than a sector.
+FlashMemorySubSector test_subsector_flash(&test_flash, 0, 128);
+#else   // TODO: Test with real flash
+FlashPartition& test_partition = FlashExternalTestPartition();
+FlashMemorySubSector& test_subsector_flash = FlashMemorySubSectorTestChunk();
 #endif  // USE_MEMORY_BUFFER
 
 FlashPartition test_subsector_partition(&test_subsector_flash, 0, 1);
@@ -53,41 +48,45 @@
   // The subsector region is assumed to be a part of the test partition.
   // In order to clear state before the test, we must erase the entire test
   // partition because erase operations are disallowed on FlashMemorySubSectors.
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // Reset KVS
   subsector_kvs.Disable();
-  ASSERT_OK(subsector_kvs.Enable());
+  ASSERT_EQ(Status::OK, subsector_kvs.Enable());
 
   // Add some data
   uint8_t value1 = 0xDA;
-  ASSERT_OK(subsector_kvs.Put(keys[0], &value1, sizeof(value1)));
+  ASSERT_EQ(Status::OK, subsector_kvs.Put(keys[0], &value1, sizeof(value1)));
 
   uint32_t value2 = 0xBAD0301f;
-  ASSERT_OK(subsector_kvs.Put(
-      keys[1], reinterpret_cast<uint8_t*>(&value2), sizeof(value2)));
+  ASSERT_EQ(Status::OK,
+            subsector_kvs.Put(
+                keys[1], reinterpret_cast<uint8_t*>(&value2), sizeof(value2)));
 
   // Verify data
   uint32_t test2;
-  EXPECT_OK(subsector_kvs.Get(
-      keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
+  EXPECT_EQ(Status::OK,
+            subsector_kvs.Get(
+                keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
   uint8_t test1;
-  ASSERT_OK(subsector_kvs.Get(
-      keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1)));
+  ASSERT_EQ(Status::OK,
+            subsector_kvs.Get(
+                keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1)));
 
   EXPECT_EQ(test1, value1);
 
   // Erase a key
-  ASSERT_OK(subsector_kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, subsector_kvs.Erase(keys[0]));
 
   // Verify it was erased
-  EXPECT_EQ(subsector_kvs
-                .Get(keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1))
-                .code(),
+  EXPECT_EQ(subsector_kvs.Get(
+                keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1)),
             Status::NOT_FOUND);
   test2 = 0;
-  ASSERT_OK(subsector_kvs.Get(
-      keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
+  ASSERT_EQ(Status::OK,
+            subsector_kvs.Get(
+                keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
   EXPECT_EQ(test2, value2);
 
   // Erase other key
@@ -101,11 +100,12 @@
   // The subsector region is assumed to be a part of the test partition.
   // In order to clear state before the test, we must erase the entire test
   // partition because erase operations are disallowed on FlashMemorySubSectors.
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // Reset KVS
   subsector_kvs.Disable();
-  ASSERT_OK(subsector_kvs.Enable());
+  ASSERT_EQ(Status::OK, subsector_kvs.Enable());
 
   // Store as much data as possible in the KVS until it fills up.
   uint64_t test = 0;
@@ -123,8 +123,8 @@
   // Even though we failed to fill the KVS, it still works, and we
   // should have the previous test value as the most recent value in the KVS.
   uint64_t value = 0;
-  ASSERT_OK(subsector_kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, subsector_kvs.Get(keys[0], &value));
   EXPECT_EQ(test - 1, value);
 }
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index fa5eaf9..92bc6a5 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -14,21 +14,22 @@
 
 #include "pw_kvs/key_value_store.h"
 
+#include "pw_span/span.h"
+
+#define USE_MEMORY_BUFFER 1
+
+#include "gtest/gtest.h"
+#include "pw_checksum/ccitt_crc16.h"
 #include "pw_kvs/assert.h"
-#include "pw_kvs/devices/flash_memory.h"
-#include "pw_kvs/os/stack_checks.h"
-#include "pw_kvs/platform/board.h"
-#include "pw_kvs/status.h"
-#include "pw_kvs/test/fixture.h"
-#include "pw_kvs/test/framework.h"
-#include "pw_kvs/test/status_macros.h"
-#include "pw_kvs/util/ccitt_crc16.h"
+#include "pw_kvs/flash_memory.h"
+#include "pw_status/status.h"
+#include "pw_string/util.h"
 
 #if USE_MEMORY_BUFFER
-#include "pw_kvs/test/fakes/in_memory_fake_flash.h"
+#include "pw_kvs/in_memory_fake_flash.h"
 #endif  // USE_MEMORY_BUFFER
 
-namespace pw {
+namespace pw::kvs {
 namespace {
 
 #if USE_MEMORY_BUFFER
@@ -41,8 +42,8 @@
 FlashPartition large_test_partition(&large_test_flash,
                                     0,
                                     large_test_flash.GetSectorCount());
-#else   // Device test
-FlashPartition& test_partition = Board::Instance().FlashExternalTestPartition();
+#else   // TODO: Test with real flash
+FlashPartition& test_partition = FlashExternalTestPartition();
 #endif  // USE_MEMORY_BUFFER
 
 KeyValueStore kvs(&test_partition);
@@ -65,13 +66,19 @@
   static constexpr uint16_t kMaxAlignmentBytes = 128;
   uint8_t alignment_buffer[kMaxAlignmentBytes] = {0};
   uint16_t aligned_bytes = size - (size % partition->GetAlignmentBytes());
-  RETURN_IF_ERROR(partition->Write(address, buf, aligned_bytes));
+  if (Status status = partition->Write(address, buf, aligned_bytes);
+      !status.ok()) {
+    return status;
+  }
   uint16_t remaining_bytes = size - aligned_bytes;
   if (remaining_bytes > 0) {
     memcpy(alignment_buffer, &buf[aligned_bytes], remaining_bytes);
-    RETURN_IF_ERROR(partition->Write(address + aligned_bytes,
-                                     alignment_buffer,
-                                     partition->GetAlignmentBytes()));
+    if (Status status = partition->Write(address + aligned_bytes,
+                                         alignment_buffer,
+                                         partition->GetAlignmentBytes());
+        !status.ok()) {
+      return status;
+    }
   }
   return Status::OK;
 }
@@ -138,51 +145,51 @@
   memset(buffer.data(), 0, buffer.size());
   while (size_to_fill > 0) {
     buffer[0]++;  // Changing buffer value so put actually does something
-    ASSERT_OK(
+    ASSERT_EQ(
+        Status::OK,
         kvs.Put(key,
                 buffer.data(),
                 chunk_len - kvs_attr.ChunkHeaderSize() - kvs_attr.KeySize()));
     size_to_fill -= chunk_len;
     chunk_len = std::min(size_to_fill, kMaxPutSize);
   }
-  ASSERT_OK(kvs.Erase(key));
+  ASSERT_EQ(Status::OK, kvs.Erase(key));
 }
 
 uint16_t CalcKvsCrc(const char* key, const void* data, size_t data_len) {
-  CcittCrc16 crc;
   static constexpr size_t kChunkKeyLengthMax = 15;
-  crc.AppendBytes(
-      ConstBuffer(reinterpret_cast<const uint8_t*>(key),
-                  pw::util::StringLength(key, kChunkKeyLengthMax)));
-  return crc.AppendBytes(
-      ConstBuffer(reinterpret_cast<const uint8_t*>(data), data_len));
+  uint16_t crc = checksum::CcittCrc16(
+      as_bytes(span(key, string::Length(key, kChunkKeyLengthMax))));
+  return checksum::CcittCrc16(
+      span(static_cast<const std::byte*>(data), data_len), crc);
 }
 
 uint16_t CalcTestPartitionCrc() {
   uint8_t buf[16];  // Read as 16 byte chunks
   CHECK_EQ(sizeof(buf) % test_partition.GetAlignmentBytes(), 0);
   CHECK_EQ(test_partition.GetSizeBytes() % sizeof(buf), 0);
-  CcittCrc16 crc;
+  uint16_t crc = checksum::kCcittCrc16DefaultInitialValue;
   for (size_t i = 0; i < test_partition.GetSizeBytes(); i += sizeof(buf)) {
     test_partition.Read(buf, i, sizeof(buf));
-    crc.AppendBytes(ConstBuffer(buf, sizeof(buf)));
+    crc = checksum::CcittCrc16(as_bytes(span(buf)), crc);
   }
-  return crc.CurrentValue();
+  return crc;
 }
 }  // namespace
 
 TEST_F(KeyValueStoreTest, FuzzTest) {
   if (test_partition.GetSectorSizeBytes() < 4 * 1024 ||
       test_partition.GetSectorCount() < 4) {
-    LOG_INFO("Sectors too small, skipping test.");
+    PW_LOG_INFO("Sectors too small, skipping test.");
     return;  // TODO: Test could be generalized
   }
   // Erase
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   const char* key1 = "Buf1";
   const char* key2 = "Buf2";
   const size_t kLargestBufSize = 3 * 1024;
@@ -192,10 +199,10 @@
   memset(buf2, 2, sizeof(buf2));
 
   // Start with things in KVS
-  ASSERT_OK(kvs.Put(key1, buf1, sizeof(buf1)));
-  ASSERT_OK(kvs.Put(key2, buf2, sizeof(buf2)));
+  ASSERT_EQ(Status::OK, kvs.Put(key1, buf1, sizeof(buf1)));
+  ASSERT_EQ(Status::OK, kvs.Put(key2, buf2, sizeof(buf2)));
   for (size_t j = 0; j < keys.size(); j++) {
-    ASSERT_OK(kvs.Put(keys[j], j));
+    ASSERT_EQ(Status::OK, kvs.Put(keys[j], j));
   }
 
   for (size_t i = 0; i < 100; i++) {
@@ -204,29 +211,29 @@
     size_t size2 = (kLargestBufSize) / (100 - i);
     for (size_t j = 0; j < 50; j++) {
       // Rewrite a single key many times, can fill up a sector
-      ASSERT_OK(kvs.Put("some_data", j));
+      ASSERT_EQ(Status::OK, kvs.Put("some_data", j));
     }
     // Delete and re-add everything
-    ASSERT_OK(kvs.Erase(key1));
-    ASSERT_OK(kvs.Put(key1, buf1, size1));
-    ASSERT_OK(kvs.Erase(key2));
-    ASSERT_OK(kvs.Put(key2, buf2, size2));
+    ASSERT_EQ(Status::OK, kvs.Erase(key1));
+    ASSERT_EQ(Status::OK, kvs.Put(key1, buf1, size1));
+    ASSERT_EQ(Status::OK, kvs.Erase(key2));
+    ASSERT_EQ(Status::OK, kvs.Put(key2, buf2, size2));
     for (size_t j = 0; j < keys.size(); j++) {
-      ASSERT_OK(kvs.Erase(keys[j]));
-      ASSERT_OK(kvs.Put(keys[j], j));
+      ASSERT_EQ(Status::OK, kvs.Erase(keys[j]));
+      ASSERT_EQ(Status::OK, kvs.Put(keys[j], j));
     }
 
     // Re-enable and verify
     kvs.Disable();
-    ASSERT_OK(kvs.Enable());
+    ASSERT_EQ(Status::OK, kvs.Enable());
     static uint8_t buf[4 * 1024];
-    ASSERT_OK(kvs.Get(key1, buf, size1));
+    ASSERT_EQ(Status::OK, kvs.Get(key1, buf, size1));
     ASSERT_EQ(memcmp(buf, buf1, size1), 0);
-    ASSERT_OK(kvs.Get(key2, buf, size2));
+    ASSERT_EQ(Status::OK, kvs.Get(key2, buf, size2));
     ASSERT_EQ(memcmp(buf2, buf2, size2), 0);
     for (size_t j = 0; j < keys.size(); j++) {
       size_t ret = 1000;
-      ASSERT_OK(kvs.Get(keys[j], &ret));
+      ASSERT_EQ(Status::OK, kvs.Get(keys[j], &ret));
       ASSERT_EQ(ret, j);
     }
   }
@@ -234,40 +241,44 @@
 
 TEST_F(KeyValueStoreTest, Basic) {
   // Erase
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Add some data
   uint8_t value1 = 0xDA;
-  ASSERT_OK(kvs.Put(keys[0], &value1, sizeof(value1)));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], &value1, sizeof(value1)));
 
   uint32_t value2 = 0xBAD0301f;
-  ASSERT_OK(
+  ASSERT_EQ(
+      Status::OK,
       kvs.Put(keys[1], reinterpret_cast<uint8_t*>(&value2), sizeof(value2)));
 
   // Verify data
   uint32_t test2;
-  EXPECT_OK(
+  EXPECT_EQ(
+      Status::OK,
       kvs.Get(keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
   uint8_t test1;
-  ASSERT_OK(
+  ASSERT_EQ(
+      Status::OK,
       kvs.Get(keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1)));
 
   EXPECT_EQ(test1, value1);
   EXPECT_EQ(test2, value2);
 
   // Erase a key
-  EXPECT_OK(kvs.Erase(keys[0]));
+  EXPECT_EQ(Status::OK, kvs.Erase(keys[0]));
 
   // Verify it was erased
-  EXPECT_EQ(kvs.Get(keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1))
-                .code(),
+  EXPECT_EQ(kvs.Get(keys[0], reinterpret_cast<uint8_t*>(&test1), sizeof(test1)),
             Status::NOT_FOUND);
   test2 = 0;
-  ASSERT_OK(
+  ASSERT_EQ(
+      Status::OK,
       kvs.Get(keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
   EXPECT_EQ(test2, value2);
 
@@ -280,27 +291,28 @@
 
 TEST_F(KeyValueStoreTest, MaxKeyLength) {
   // Erase
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Add some data
   char key[16] = "123456789abcdef";  // key length 15 (without \0)
   int value = 1;
-  ASSERT_OK(kvs.Put(key, value));
+  ASSERT_EQ(Status::OK, kvs.Put(key, value));
 
   // Verify data
   int test = 0;
-  ASSERT_OK(kvs.Get(key, &test));
+  ASSERT_EQ(Status::OK, kvs.Get(key, &test));
   EXPECT_EQ(test, value);
 
   // Erase a key
   kvs.Erase(key);
 
   // Verify it was erased
-  EXPECT_EQ(kvs.Get(key, &test).code(), Status::NOT_FOUND);
+  EXPECT_EQ(kvs.Get(key, &test), Status::NOT_FOUND);
 }
 
 TEST_F(KeyValueStoreTest, LargeBuffers) {
@@ -321,21 +333,22 @@
   const size_t kAvailSectorSpace = test_partition.GetSectorSizeBytes() *
                                    (test_partition.GetSectorCount() - 1);
   if (kAvailSectorSpace < kMinSize) {
-    LOG_INFO("KVS too small, skipping test.");
+    PW_LOG_INFO("KVS too small, skipping test.");
     return;
   }
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Add and verify
   for (unsigned add_idx = 0; add_idx < keys.size(); add_idx++) {
     memset(buffer.data(), add_idx, buffer.size());
-    ASSERT_OK(kvs.Put(keys[add_idx], buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK, kvs.Put(keys[add_idx], buffer.data(), buffer.size()));
     EXPECT_EQ(kvs.KeyCount(), add_idx + 1);
     for (unsigned verify_idx = 0; verify_idx <= add_idx; verify_idx++) {
       memset(buffer.data(), 0, buffer.size());
-      ASSERT_OK(kvs.Get(keys[verify_idx], buffer.data(), buffer.size()));
+      ASSERT_EQ(Status::OK,
+                kvs.Get(keys[verify_idx], buffer.data(), buffer.size()));
       for (unsigned i = 0; i < buffer.size(); i++) {
         EXPECT_EQ(buffer[i], verify_idx);
       }
@@ -344,16 +357,16 @@
 
   // Erase and verify
   for (unsigned erase_idx = 0; erase_idx < keys.size(); erase_idx++) {
-    ASSERT_OK(kvs.Erase(keys[erase_idx]));
+    ASSERT_EQ(Status::OK, kvs.Erase(keys[erase_idx]));
     EXPECT_EQ(kvs.KeyCount(), keys.size() - erase_idx - 1);
     for (unsigned verify_idx = 0; verify_idx < keys.size(); verify_idx++) {
       memset(buffer.data(), 0, buffer.size());
       if (verify_idx <= erase_idx) {
-        ASSERT_EQ(
-            kvs.Get(keys[verify_idx], buffer.data(), buffer.size()).code(),
-            Status::NOT_FOUND);
+        ASSERT_EQ(kvs.Get(keys[verify_idx], buffer.data(), buffer.size()),
+                  Status::NOT_FOUND);
       } else {
-        ASSERT_OK(kvs.Get(keys[verify_idx], buffer.data(), buffer.size()));
+        ASSERT_EQ(Status::OK,
+                  kvs.Get(keys[verify_idx], buffer.data(), buffer.size()));
         for (uint32_t i = 0; i < buffer.size(); i++) {
           EXPECT_EQ(buffer[i], verify_idx);
         }
@@ -377,39 +390,40 @@
   const size_t kAvailSectorSpace = test_partition.GetSectorSizeBytes() *
                                    (test_partition.GetSectorCount() - 1);
   if (kAvailSectorSpace < kMinSize) {
-    LOG_INFO("KVS too small, skipping test.");
+    PW_LOG_INFO("KVS too small, skipping test.");
     return;
   }
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Add some items
   for (unsigned add_idx = 0; add_idx < keys.size(); add_idx++) {
     memset(buffer.data(), add_idx, buffer.size());
-    ASSERT_OK(kvs.Put(keys[add_idx], buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK, kvs.Put(keys[add_idx], buffer.data(), buffer.size()));
     EXPECT_EQ(kvs.KeyCount(), add_idx + 1);
   }
 
   // Enable different KVS which should be able to properly setup the same map
   // from what is stored in flash.
-  ASSERT_OK(kvs_local_.Enable());
+  ASSERT_EQ(Status::OK, kvs_local_.Enable());
   EXPECT_EQ(kvs_local_.KeyCount(), keys.size());
 
   // Ensure adding to new KVS works
   uint8_t value = 0xDA;
   const char* key = "new_key";
-  ASSERT_OK(kvs_local_.Put(key, &value, sizeof(value)));
+  ASSERT_EQ(Status::OK, kvs_local_.Put(key, &value, sizeof(value)));
   uint8_t test;
-  ASSERT_OK(kvs_local_.Get(key, &test, sizeof(test)));
+  ASSERT_EQ(Status::OK, kvs_local_.Get(key, &test, sizeof(test)));
   EXPECT_EQ(value, test);
   EXPECT_EQ(kvs_local_.KeyCount(), keys.size() + 1);
 
   // Verify previous data
   for (unsigned verify_idx = 0; verify_idx < keys.size(); verify_idx++) {
     memset(buffer.data(), 0, buffer.size());
-    ASSERT_OK(kvs_local_.Get(keys[verify_idx], buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK,
+              kvs_local_.Get(keys[verify_idx], buffer.data(), buffer.size()));
     for (uint32_t i = 0; i < buffer.size(); i++) {
       EXPECT_EQ(buffer[i], verify_idx);
     }
@@ -421,18 +435,18 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Calculate number of elements to ensure multiple sectors are required.
   uint16_t add_count =
       (test_partition.GetSectorSizeBytes() / buffer.size()) + 1;
 
   if (kvs.GetMaxKeys() < add_count) {
-    LOG_INFO("Sector size too large, skipping test.");
+    PW_LOG_INFO("Sector size too large, skipping test.");
     return;  // this chip has very large sectors, test won't work
   }
   if (test_partition.GetSectorCount() < 3) {
-    LOG_INFO("Not enough sectors, skipping test.");
+    PW_LOG_INFO("Not enough sectors, skipping test.");
     return;  // need at least 3 sectors for multi-sector test
   }
 
@@ -440,14 +454,14 @@
   for (unsigned add_idx = 0; add_idx < add_count; add_idx++) {
     memset(buffer.data(), add_idx, buffer.size());
     snprintf(key, sizeof(key), "key_%u", add_idx);
-    ASSERT_OK(kvs.Put(key, buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK, kvs.Put(key, buffer.data(), buffer.size()));
     EXPECT_EQ(kvs.KeyCount(), add_idx + 1);
   }
 
   for (unsigned verify_idx = 0; verify_idx < add_count; verify_idx++) {
     memset(buffer.data(), 0, buffer.size());
     snprintf(key, sizeof(key), "key_%u", verify_idx);
-    ASSERT_OK(kvs.Get(key, buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK, kvs.Get(key, buffer.data(), buffer.size()));
     for (uint32_t i = 0; i < buffer.size(); i++) {
       EXPECT_EQ(buffer[i], verify_idx);
     }
@@ -456,7 +470,7 @@
   // Check erase
   for (unsigned erase_idx = 0; erase_idx < add_count; erase_idx++) {
     snprintf(key, sizeof(key), "key_%u", erase_idx);
-    ASSERT_OK(kvs.Erase(key));
+    ASSERT_EQ(Status::OK, kvs.Erase(key));
     EXPECT_EQ(kvs.KeyCount(), add_count - erase_idx - 1);
   }
 }
@@ -466,24 +480,26 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Write first value
   const uint8_t kValue1 = 0xDA;
   const uint8_t kValue2 = 0x12;
   const char* key = "the_key";
-  ASSERT_OK(kvs.Put(key, &kValue1, sizeof(kValue1)));
+  ASSERT_EQ(Status::OK, kvs.Put(key, &kValue1, sizeof(kValue1)));
 
   // Verify
   uint8_t value;
-  ASSERT_OK(kvs.Get(key, reinterpret_cast<uint8_t*>(&value), sizeof(value)));
+  ASSERT_EQ(Status::OK,
+            kvs.Get(key, reinterpret_cast<uint8_t*>(&value), sizeof(value)));
   EXPECT_EQ(kValue1, value);
 
   // Write new value for key
-  ASSERT_OK(kvs.Put(key, &kValue2, sizeof(kValue2)));
+  ASSERT_EQ(Status::OK, kvs.Put(key, &kValue2, sizeof(kValue2)));
 
   // Verify
-  ASSERT_OK(kvs.Get(key, reinterpret_cast<uint8_t*>(&value), sizeof(value)));
+  ASSERT_EQ(Status::OK,
+            kvs.Get(key, reinterpret_cast<uint8_t*>(&value), sizeof(value)));
   EXPECT_EQ(kValue2, value);
 
   // Verify only 1 element exists
@@ -495,7 +511,7 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   const char* key = "the_key";
   constexpr uint8_t kReadSize = 16;  // needs to be a multiple of alignment
@@ -507,13 +523,14 @@
   for (uint8_t i = 0; i < kTestBufferSize; i++) {
     buffer[i] = i;
   }
-  ASSERT_OK(kvs.Put(key, buffer.data(), kTestBufferSize));
+  ASSERT_EQ(Status::OK, kvs.Put(key, buffer.data(), kTestBufferSize));
   EXPECT_EQ(kvs.KeyCount(), 1);
 
   // Read in small chunks and verify
   for (int i = 0; i < kTestBufferSize / kReadSize; i++) {
     memset(buffer.data(), 0, buffer.size());
-    ASSERT_OK(kvs.Get(key, buffer.data(), kReadSize, i * kReadSize));
+    ASSERT_EQ(Status::OK,
+              kvs.Get(key, buffer.data(), kReadSize, i * kReadSize));
     for (unsigned j = 0; j < kReadSize; j++) {
       ASSERT_EQ(buffer[j], j + i * kReadSize);
     }
@@ -526,7 +543,7 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Calculate number of elements to ensure multiple sectors are required.
   unsigned add_count =
@@ -540,13 +557,13 @@
     if (add_idx == add_count - 1) {  // last value
       memset(buffer.data(), kGoodVal, buffer.size());
     }
-    ASSERT_OK(kvs.Put(key, buffer.data(), buffer.size()));
+    ASSERT_EQ(Status::OK, kvs.Put(key, buffer.data(), buffer.size()));
     EXPECT_EQ(kvs.KeyCount(), 1);
   }
 
   // Verify
   memset(buffer.data(), 0, buffer.size());
-  ASSERT_OK(kvs.Get(key, buffer.data(), buffer.size()));
+  ASSERT_EQ(Status::OK, kvs.Get(key, buffer.data(), buffer.size()));
   for (uint32_t i = 0; i < buffer.size(); i++) {
     ASSERT_EQ(buffer[i], kGoodVal);
   }
@@ -559,7 +576,7 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   ASSERT_EQ(std::strlen(keys[0]), 8U);  // Easier for alignment
   ASSERT_EQ(std::strlen(keys[2]), 8U);  // Easier for alignment
@@ -570,13 +587,13 @@
   constexpr uint8_t kKey0Pattern = 0xBA;
 
   memset(buffer.data(), kKey0Pattern, kvs_attr.DataSize());
-  ASSERT_OK(kvs.Put(keys[0], buffer.data(), kvs_attr.DataSize()));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], buffer.data(), kvs_attr.DataSize()));
   bytes_remaining -= kvs_attr.MinPutSize();
   memset(buffer.data(), 1, kvs_attr.DataSize());
-  ASSERT_OK(kvs.Put(keys[2], buffer.data(), kvs_attr.DataSize()));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[2], buffer.data(), kvs_attr.DataSize()));
   bytes_remaining -= kvs_attr.MinPutSize();
   EXPECT_EQ(kvs.KeyCount(), 2);
-  ASSERT_OK(kvs.Erase(keys[2]));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[2]));
   bytes_remaining -= kvs_attr.EraseSize();
   EXPECT_EQ(kvs.KeyCount(), 1);
 
@@ -586,7 +603,7 @@
 
   // Verify key[0]
   memset(buffer.data(), 0, kvs_attr.DataSize());
-  ASSERT_OK(kvs.Get(keys[0], buffer.data(), kvs_attr.DataSize()));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], buffer.data(), kvs_attr.DataSize()));
   for (uint32_t i = 0; i < kvs_attr.DataSize(); i++) {
     EXPECT_EQ(buffer[i], kKey0Pattern);
   }
@@ -597,19 +614,19 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   const uint8_t kValue1 = 0xDA;
   const uint8_t kValue2 = 0x12;
   uint8_t value[1];
-  ASSERT_OK(kvs.Put(keys[0], &kValue1, sizeof(kValue1)));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], &kValue1, sizeof(kValue1)));
   EXPECT_EQ(kvs.KeyCount(), 1);
-  ASSERT_OK(kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[0]));
   EXPECT_EQ(kvs.Get(keys[0], value, sizeof(value)), Status::NOT_FOUND);
-  ASSERT_OK(kvs.Put(keys[1], &kValue1, sizeof(kValue1)));
-  ASSERT_OK(kvs.Put(keys[2], &kValue2, sizeof(kValue2)));
-  ASSERT_OK(kvs.Erase(keys[1]));
-  EXPECT_OK(kvs.Get(keys[2], value, sizeof(value)));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[1], &kValue1, sizeof(kValue1)));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[2], &kValue2, sizeof(kValue2)));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[1]));
+  EXPECT_EQ(Status::OK, kvs.Get(keys[2], value, sizeof(value)));
   EXPECT_EQ(kValue2, value[0]);
 
   EXPECT_EQ(kvs.KeyCount(), 1);
@@ -670,38 +687,48 @@
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Alignment to 16
   };
   // clang-format on
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
 
   // We don't actually care about the size values provided, since we are only
   // using kvs_attr to get Sector Size
   KvsAttributes kvs_attr(8, 8);
   if (test_partition.GetAlignmentBytes() == 1) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned1Top, sizeof(kKvsTestDataAligned1Top)));
-    ASSERT_OK(test_partition.Write(kvs_attr.SectorHeaderSize(),
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned1Top, sizeof(kKvsTestDataAligned1Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(kvs_attr.SectorHeaderSize(),
                                    kKvsTestDataAligned1Bottom,
                                    sizeof(kKvsTestDataAligned1Bottom)));
   } else if (test_partition.GetAlignmentBytes() == 2) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned2Top, sizeof(kKvsTestDataAligned2Top)));
-    ASSERT_OK(test_partition.Write(kvs_attr.SectorHeaderSize(),
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned2Top, sizeof(kKvsTestDataAligned2Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(kvs_attr.SectorHeaderSize(),
                                    kKvsTestDataAligned2Bottom,
                                    sizeof(kKvsTestDataAligned2Bottom)));
   } else if (test_partition.GetAlignmentBytes() == 8) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned8Top, sizeof(kKvsTestDataAligned8Top)));
-    ASSERT_OK(test_partition.Write(kvs_attr.SectorHeaderSize(),
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned8Top, sizeof(kKvsTestDataAligned8Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(kvs_attr.SectorHeaderSize(),
                                    kKvsTestDataAligned8Bottom,
                                    sizeof(kKvsTestDataAligned8Bottom)));
   } else if (test_partition.GetAlignmentBytes() == 16) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned16Top, sizeof(kKvsTestDataAligned16Top)));
-    ASSERT_OK(test_partition.Write(kvs_attr.SectorHeaderSize(),
+    ASSERT_EQ(
+        Status::OK,
+        test_partition.Write(
+            0, kKvsTestDataAligned16Top, sizeof(kKvsTestDataAligned16Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(kvs_attr.SectorHeaderSize(),
                                    kKvsTestDataAligned16Bottom,
                                    sizeof(kKvsTestDataAligned16Bottom)));
   } else {
-    LOG_ERROR("Test only supports 1, 2, 8 and 16 byte alignments.");
-    ASSERT_OK(false);
+    PW_LOG_ERROR("Test only supports 1, 2, 8 and 16 byte alignments.");
+    ASSERT_EQ(Status::OK, false);
   }
 
   EXPECT_EQ(kvs_local_.Enable(), Status::OK);
@@ -711,21 +738,22 @@
 
   // Value with correct CRC should still be available.
   uint32_t test2 = 0;
-  ASSERT_OK(kvs_local_.Get(
-      keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
+  ASSERT_EQ(Status::OK,
+            kvs_local_.Get(
+                keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
   EXPECT_EQ(kTestPattern, test2);
 
   // Test rewriting over corrupted data.
-  ASSERT_OK(kvs_local_.Put(keys[0], kTestPattern));
+  ASSERT_EQ(Status::OK, kvs_local_.Put(keys[0], kTestPattern));
   test2 = 0;
-  EXPECT_OK(kvs_local_.Get(keys[0], &test2));
+  EXPECT_EQ(Status::OK, kvs_local_.Get(keys[0], &test2));
   EXPECT_EQ(kTestPattern, test2);
 
   // Check correct when re-enabled
   kvs_local_.Disable();
   EXPECT_EQ(kvs_local_.Enable(), Status::OK);
   test2 = 0;
-  EXPECT_OK(kvs_local_.Get(keys[0], &test2));
+  EXPECT_EQ(Status::OK, kvs_local_.Get(keys[0], &test2));
   EXPECT_EQ(kTestPattern, test2);
 }
 
@@ -744,10 +772,11 @@
     // Test only runs on 1 byte alignment partitions
     test_partition.Erase(0, test_partition.GetSectorCount());
     test_partition.Write(0, kKvsTestDataAligned1, sizeof(kKvsTestDataAligned1));
-    EXPECT_OK(kvs_local_.Enable());
+    EXPECT_EQ(Status::OK, kvs_local_.Enable());
     uint32_t test2 = 0;
-    ASSERT_OK(kvs_local_.Get(
-        keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
+    ASSERT_EQ(Status::OK,
+              kvs_local_.Get(
+                  keys[1], reinterpret_cast<uint8_t*>(&test2), sizeof(test2)));
     EXPECT_EQ(kTestPattern, test2);
   }
 }
@@ -757,16 +786,17 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   kvs.Disable();
 
-  EXPECT_OK(kvs_local_.Enable());
+  EXPECT_EQ(Status::OK, kvs_local_.Enable());
   // Write value
   const uint8_t kValue = 0xDA;
-  ASSERT_OK(kvs_local_.Put(keys[0], &kValue, sizeof(kValue)));
+  ASSERT_EQ(Status::OK, kvs_local_.Put(keys[0], &kValue, sizeof(kValue)));
   uint8_t value;
-  ASSERT_OK(kvs_local_.Get(
-      keys[0], reinterpret_cast<uint8_t*>(&value), sizeof(value)));
+  ASSERT_EQ(Status::OK,
+            kvs_local_.Get(
+                keys[0], reinterpret_cast<uint8_t*>(&value), sizeof(value)));
 
   // Verify
   EXPECT_EQ(kValue, value);
@@ -777,19 +807,19 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Write value
   const uint8_t kValue = 0xDA;
-  ASSERT_OK(kvs.Put(keys[0], &kValue, sizeof(kValue)));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], &kValue, sizeof(kValue)));
 
-  ASSERT_OK(kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[0]));
   uint8_t value[1];
   ASSERT_EQ(kvs.Get(keys[0], value, sizeof(value)), Status::NOT_FOUND);
 
   // Reset KVS, ensure captured at enable
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   ASSERT_EQ(kvs.Get(keys[0], value, sizeof(value)), Status::NOT_FOUND);
 }
@@ -798,14 +828,14 @@
   test_partition.Erase(0, test_partition.GetSectorCount());
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   // Store a value with the convenience method.
   const uint32_t kValue = 0x12345678;
-  ASSERT_OK(kvs.Put(keys[0], kValue));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], kValue));
 
   // Read it back with the other convenience method.
   uint32_t value;
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(kValue, value);
 
   // Make sure we cannot get something where size isn't what we expect
@@ -854,53 +884,64 @@
   };
   // clang-format on
 
-  ASSERT_OK(test_partition.Erase(0, test_partition.GetSectorCount()));
+  ASSERT_EQ(Status::OK,
+            test_partition.Erase(0, test_partition.GetSectorCount()));
   // We don't actually care about the size values provided, since we are only
   // using kvs_attr to get Sector Size
   KvsAttributes kvs_attr(8, 8);
-  pw::FlashPartition::Address address = kvs_attr.SectorHeaderSize();
+  FlashPartition::Address address = kvs_attr.SectorHeaderSize();
   if (test_partition.GetAlignmentBytes() == 1) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned1Top, sizeof(kKvsTestDataAligned1Top)));
-    ASSERT_OK(test_partition.Write(address,
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned1Top, sizeof(kKvsTestDataAligned1Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(address,
                                    kKvsTestDataAligned1Bottom,
                                    sizeof(kKvsTestDataAligned1Bottom)));
     address += sizeof(kKvsTestDataAligned1Bottom);
   } else if (test_partition.GetAlignmentBytes() == 2) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned2Top, sizeof(kKvsTestDataAligned2Top)));
-    ASSERT_OK(test_partition.Write(address,
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned2Top, sizeof(kKvsTestDataAligned2Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(address,
                                    kKvsTestDataAligned2Bottom,
                                    sizeof(kKvsTestDataAligned2Bottom)));
     address += sizeof(kKvsTestDataAligned2Bottom);
   } else if (test_partition.GetAlignmentBytes() == 8) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned8Top, sizeof(kKvsTestDataAligned8Top)));
-    ASSERT_OK(test_partition.Write(address,
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(
+                  0, kKvsTestDataAligned8Top, sizeof(kKvsTestDataAligned8Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(address,
                                    kKvsTestDataAligned8Bottom,
                                    sizeof(kKvsTestDataAligned8Bottom)));
     address += sizeof(kKvsTestDataAligned8Bottom);
   } else if (test_partition.GetAlignmentBytes() == 16) {
-    ASSERT_OK(test_partition.Write(
-        0, kKvsTestDataAligned16Top, sizeof(kKvsTestDataAligned16Top)));
-    ASSERT_OK(test_partition.Write(address,
+    ASSERT_EQ(
+        Status::OK,
+        test_partition.Write(
+            0, kKvsTestDataAligned16Top, sizeof(kKvsTestDataAligned16Top)));
+    ASSERT_EQ(Status::OK,
+              test_partition.Write(address,
                                    kKvsTestDataAligned16Bottom,
                                    sizeof(kKvsTestDataAligned16Bottom)));
     address += sizeof(kKvsTestDataAligned16Bottom);
   } else {
-    LOG_ERROR("Test only supports 1, 2, 8 and 16 byte alignments.");
+    PW_LOG_ERROR("Test only supports 1, 2, 8 and 16 byte alignments.");
     ASSERT_EQ(true, false);
   }
 
-  ASSERT_OK(kvs_local_.Enable());
+  ASSERT_EQ(Status::OK, kvs_local_.Enable());
   EXPECT_TRUE(kvs_local_.IsEnabled());
 
   // Put in same key/value pair
-  ASSERT_OK(kvs_local_.Put(keys[1], kTestPattern));
+  ASSERT_EQ(Status::OK, kvs_local_.Put(keys[1], kTestPattern));
 
   bool is_erased = false;
-  ASSERT_OK(test_partition.IsChunkErased(
-      address, test_partition.GetAlignmentBytes(), &is_erased));
+  ASSERT_EQ(Status::OK,
+            test_partition.IsChunkErased(
+                address, test_partition.GetAlignmentBytes(), &is_erased));
   EXPECT_EQ(is_erased, true);
 }
 
@@ -909,14 +950,14 @@
 // the sector.
 TEST_F(KeyValueStoreTest, FillSector2) {
   if (test_partition.GetSectorCount() < 3) {
-    LOG_INFO("Not enough sectors, skipping test.");
+    PW_LOG_INFO("Not enough sectors, skipping test.");
     return;  // need at least 3 sectors
   }
 
   // Reset KVS
   kvs.Disable();
   test_partition.Erase(0, test_partition.GetSectorCount());
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Start of by filling flash sector to near full
   constexpr int kHalfBufferSize = buffer.size() / 2;
@@ -931,11 +972,12 @@
   size_t new_keyvalue_size = 0;
   size_t alignment = test_partition.GetAlignmentBytes();
   // Starts on second sector since it will try to keep first sector free
-  pw::FlashPartition::Address read_address =
+  FlashPartition::Address read_address =
       2 * test_partition.GetSectorSizeBytes() - alignment;
   for (; read_address > 0; read_address -= alignment) {
     bool is_erased = false;
-    ASSERT_OK(
+    ASSERT_EQ(
+        Status::OK,
         test_partition.IsChunkErased(read_address, alignment, &is_erased));
     if (is_erased) {
       new_keyvalue_size += alignment;
@@ -953,15 +995,15 @@
   constexpr uint8_t kTestPattern = 0xBA;
   new_keyvalue_size -= kValueLessThanChunkHeaderSize;
   memset(buffer.data(), kTestPattern, new_keyvalue_size);
-  ASSERT_OK(kvs.Put(kNewKey, buffer.data(), new_keyvalue_size));
+  ASSERT_EQ(Status::OK, kvs.Put(kNewKey, buffer.data(), new_keyvalue_size));
 
   // In failed corner case, adding new key is deceptively successful. It isn't
   // until KVS is disabled and reenabled that issue can be detected.
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Might as well check that new key-value is what we expect it to be
-  ASSERT_OK(kvs.Get(kNewKey, buffer.data(), new_keyvalue_size));
+  ASSERT_EQ(Status::OK, kvs.Get(kNewKey, buffer.data(), new_keyvalue_size));
   for (size_t i = 0; i < new_keyvalue_size; i++) {
     EXPECT_EQ(buffer[i], kTestPattern);
   }
@@ -980,7 +1022,7 @@
 
   // Reset KVS
   test_partition.Erase(0, test_partition.GetSectorCount());
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Try some case that are expected to fail
   ASSERT_EQ(kvs.GetValueSize(keys[0], &value_size), Status::NOT_FOUND);
@@ -989,12 +1031,12 @@
 
   // Add key[0] and test we get the right value size for it.
   memset(buffer.data(), kKey0Pattern, kSizeOfValueToFill);
-  ASSERT_OK(kvs.Put(keys[0], buffer.data(), kSizeOfValueToFill));
-  ASSERT_OK(kvs.GetValueSize(keys[0], &value_size));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], buffer.data(), kSizeOfValueToFill));
+  ASSERT_EQ(Status::OK, kvs.GetValueSize(keys[0], &value_size));
   ASSERT_EQ(value_size, kSizeOfValueToFill);
 
   // Verify after erase key is not found
-  ASSERT_OK(kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[0]));
   ASSERT_EQ(kvs.GetValueSize(keys[0], &value_size), Status::NOT_FOUND);
 }
 
@@ -1002,7 +1044,7 @@
   // Reset KVS
   kvs.Disable();
   test_partition.Erase(0, test_partition.GetSectorCount());
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   // Get exactly the number of bytes that can fit in the space remaining for
   // a large value, accounting for alignment.
@@ -1035,15 +1077,15 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
-  ASSERT_OK(kvs.Put(kKey, kValue1));
+  ASSERT_EQ(Status::OK, kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Put(kKey, kValue1));
 
   // Now try to rewrite with the similar value.
-  ASSERT_OK(kvs.Put(kKey, kValue2));
+  ASSERT_EQ(Status::OK, kvs.Put(kKey, kValue2));
 
   // Read it back and check it is correct
   char value[3];
-  ASSERT_OK(kvs.Get(kKey, value, sizeof(value)));
+  ASSERT_EQ(Status::OK, kvs.Get(kKey, value, sizeof(value)));
   ASSERT_EQ(memcmp(value, kValue2, sizeof(value)), 0);
 }
 
@@ -1052,11 +1094,11 @@
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   const uint8_t kValue = 0xDA;
-  ASSERT_OK(kvs.Put(keys[0], &kValue, sizeof(kValue)));
-  ASSERT_OK(kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, kvs.Put(keys[0], &kValue, sizeof(kValue)));
+  ASSERT_EQ(Status::OK, kvs.Erase(keys[0]));
   uint16_t crc = CalcTestPartitionCrc();
   EXPECT_EQ(kvs.Erase(keys[0]), Status::NOT_FOUND);
   // Verify the flash has not changed
@@ -1073,18 +1115,18 @@
 
   test_partition.Erase(0, test_partition.GetSectorCount());
 
-  ASSERT_OK(kvs1.Enable());
-  ASSERT_OK(kvs2.Enable());
+  ASSERT_EQ(Status::OK, kvs1.Enable());
+  ASSERT_EQ(Status::OK, kvs2.Enable());
 
   int values1[3] = {100, 101, 102};
-  ASSERT_OK(kvs1.Put(keys[0], values1[0]));
-  ASSERT_OK(kvs1.Put(keys[1], values1[1]));
-  ASSERT_OK(kvs1.Put(keys[2], values1[2]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
 
   int values2[3] = {200, 201, 202};
-  ASSERT_OK(kvs2.Put(keys[0], values2[0]));
-  ASSERT_OK(kvs2.Put(keys[1], values2[1]));
-  ASSERT_OK(kvs2.Erase(keys[1]));
+  ASSERT_EQ(Status::OK, kvs2.Put(keys[0], values2[0]));
+  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values2[1]));
+  ASSERT_EQ(Status::OK, kvs2.Erase(keys[1]));
 
   kvs1.Disable();
   kvs2.Disable();
@@ -1094,19 +1136,20 @@
   // key 2 is only in first sector
 
   uint64_t mark_clean_count = 5;
-  ASSERT_OK(PaddedWrite(&test_partition_sector1,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector1,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   int value;
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values2[0], value);
   ASSERT_EQ(kvs.Get(keys[1], &value), Status::NOT_FOUND);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values1[2], value);
 
   if (test_partition.GetSectorCount() == 2) {
@@ -1118,25 +1161,29 @@
   }
 
   mark_clean_count--;
-  ASSERT_OK(PaddedWrite(&test_partition_sector2,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector2,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   EXPECT_EQ(kvs.PendingCleanCount(), 2u);
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values1[0], value);
-  ASSERT_OK(kvs.Get(keys[1], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[1], &value));
   ASSERT_EQ(values1[1], value);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values1[2], value);
 }
 
+// TODO: temporary
+size_t CurrentTaskStackFree() { return -1; }
+
 TEST_F(KeyValueStoreTest, PartialClean) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 2) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   StackHeavyPartialClean();
@@ -1149,40 +1196,42 @@
   KeyValueStore kvs1(&test_partition_sector1);
   test_partition.Erase(0, test_partition.GetSectorCount());
 
-  ASSERT_OK(kvs1.Enable());
+  ASSERT_EQ(Status::OK, kvs1.Enable());
 
   int values1[3] = {100, 101, 102};
-  ASSERT_OK(kvs1.Put(keys[0], values1[0]));
-  ASSERT_OK(kvs1.Put(keys[1], values1[1]));
-  ASSERT_OK(kvs1.Put(keys[2], values1[2] - 100));  //  force a rewrite
-  ASSERT_OK(kvs1.Put(keys[2], values1[2]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
+  ASSERT_EQ(Status::OK,
+            kvs1.Put(keys[2], values1[2] - 100));  //  force a rewrite
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
 
   kvs1.Disable();
 
   uint64_t mark_clean_count = 5;
-  ASSERT_OK(PaddedWrite(&test_partition_sector1,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector1,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
 
   // Reset KVS
   kvs.Disable();
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   int value;
   EXPECT_EQ(kvs.PendingCleanCount(), 1u);
-  ASSERT_OK(kvs.CleanAll());
+  ASSERT_EQ(Status::OK, kvs.CleanAll());
   EXPECT_EQ(kvs.PendingCleanCount(), 0u);
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values1[0], value);
-  ASSERT_OK(kvs.Get(keys[1], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[1], &value));
   ASSERT_EQ(values1[1], value);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values1[2], value);
 }
 
 TEST_F(KeyValueStoreTest, CleanAll) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 1) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   StackHeavyCleanAll();
@@ -1198,18 +1247,18 @@
 
   test_partition.Erase(0, test_partition.GetSectorCount());
 
-  ASSERT_OK(kvs1.Enable());
-  ASSERT_OK(kvs2.Enable());
+  ASSERT_EQ(Status::OK, kvs1.Enable());
+  ASSERT_EQ(Status::OK, kvs2.Enable());
 
   int values1[3] = {100, 101, 102};
-  ASSERT_OK(kvs1.Put(keys[0], values1[0]));
-  ASSERT_OK(kvs1.Put(keys[1], values1[1]));
-  ASSERT_OK(kvs1.Put(keys[2], values1[2]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
 
   int values2[3] = {200, 201, 202};
-  ASSERT_OK(kvs2.Put(keys[0], values2[0]));
-  ASSERT_OK(kvs2.Put(keys[1], values2[1]));
-  ASSERT_OK(kvs2.Erase(keys[1]));
+  ASSERT_EQ(Status::OK, kvs2.Put(keys[0], values2[0]));
+  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values2[1]));
+  ASSERT_EQ(Status::OK, kvs2.Erase(keys[1]));
 
   kvs1.Disable();
   kvs2.Disable();
@@ -1220,18 +1269,19 @@
   // key 2 is only in first sector
 
   uint64_t mark_clean_count = 4569877515;
-  ASSERT_OK(PaddedWrite(&test_partition_sector1,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector1,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
 
   // Reset KVS
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   int value;
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values2[0], value);
   ASSERT_EQ(kvs.Get(keys[1], &value), Status::NOT_FOUND);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values1[2], value);
 
   if (test_partition.GetSectorCount() == 2) {
@@ -1245,24 +1295,25 @@
   kvs.Disable();
 
   mark_clean_count--;
-  ASSERT_OK(PaddedWrite(&test_partition_sector2,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector2,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
   // Reset KVS
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
   EXPECT_EQ(kvs.PendingCleanCount(), 2u);
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values1[0], value);
-  ASSERT_OK(kvs.Get(keys[1], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[1], &value));
   ASSERT_EQ(values1[1], value);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values1[2], value);
 }
 
 TEST_F(KeyValueStoreTest, PartialCleanLargeCounts) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 2) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   StackHeavyPartialCleanLargeCounts();
@@ -1280,31 +1331,31 @@
 
   test_partition.Erase(0, test_partition.GetSectorCount());
 
-  ASSERT_OK(kvs1.Enable());
-  ASSERT_OK(kvs2.Enable());
+  ASSERT_EQ(Status::OK, kvs1.Enable());
+  ASSERT_EQ(Status::OK, kvs2.Enable());
 
   int values[3] = {100, 101};
-  ASSERT_OK(kvs1.Put(keys[0], values[0]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values[0]));
   ASSERT_FALSE(kvs1.HasEmptySector());
-  ASSERT_OK(kvs2.Put(keys[1], values[1]));
+  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values[1]));
   ASSERT_FALSE(kvs2.HasEmptySector());
 
   kvs1.Disable();
   kvs2.Disable();
 
   // Reset KVS
-  ASSERT_OK(kvs_both.Enable());
+  ASSERT_EQ(Status::OK, kvs_both.Enable());
   ASSERT_TRUE(kvs_both.HasEmptySector());
   int value;
-  ASSERT_OK(kvs_both.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs_both.Get(keys[0], &value));
   ASSERT_EQ(values[0], value);
-  ASSERT_OK(kvs_both.Get(keys[1], &value));
+  ASSERT_EQ(Status::OK, kvs_both.Get(keys[1], &value));
   ASSERT_EQ(values[1], value);
 }
 
 TEST_F(KeyValueStoreTest, RecoverNoFreeSectors) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 3) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   StackHeavyRecoverNoFreeSectors();
@@ -1319,45 +1370,46 @@
 
   test_partition.Erase(0, test_partition.GetSectorCount());
 
-  ASSERT_OK(kvs1.Enable());
+  ASSERT_EQ(Status::OK, kvs1.Enable());
 
   int values[3] = {100, 101, 102};
-  ASSERT_OK(kvs1.Put(keys[0], values[0]));
-  ASSERT_OK(kvs1.Put(keys[1], values[1]));
-  ASSERT_OK(kvs1.Put(keys[2], values[2]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values[0]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values[1]));
+  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values[2]));
 
   kvs1.Disable();
   kvs.Disable();
 
   uint64_t mark_clean_count = 1;
-  ASSERT_OK(PaddedWrite(&test_partition_sector1,
+  ASSERT_EQ(Status::OK,
+            PaddedWrite(&test_partition_sector1,
                         RoundUpForAlignment(KeyValueStore::kHeaderSize),
                         reinterpret_cast<uint8_t*>(&mark_clean_count),
                         sizeof(uint64_t)));
 
   // Reset KVS
-  ASSERT_OK(kvs.Enable());
+  ASSERT_EQ(Status::OK, kvs.Enable());
 
   EXPECT_EQ(kvs.PendingCleanCount(), 1u);
 
   bool all_sectors_have_been_cleaned = false;
-  ASSERT_OK(kvs.CleanOneSector(&all_sectors_have_been_cleaned));
+  ASSERT_EQ(Status::OK, kvs.CleanOneSector(&all_sectors_have_been_cleaned));
   EXPECT_EQ(all_sectors_have_been_cleaned, true);
   EXPECT_EQ(kvs.PendingCleanCount(), 0u);
-  ASSERT_OK(kvs.CleanOneSector(&all_sectors_have_been_cleaned));
+  ASSERT_EQ(Status::OK, kvs.CleanOneSector(&all_sectors_have_been_cleaned));
   EXPECT_EQ(all_sectors_have_been_cleaned, true);
   int value;
-  ASSERT_OK(kvs.Get(keys[0], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[0], &value));
   ASSERT_EQ(values[0], value);
-  ASSERT_OK(kvs.Get(keys[1], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[1], &value));
   ASSERT_EQ(values[1], value);
-  ASSERT_OK(kvs.Get(keys[2], &value));
+  ASSERT_EQ(Status::OK, kvs.Get(keys[2], &value));
   ASSERT_EQ(values[2], value);
 }
 
 TEST_F(KeyValueStoreTest, CleanOneSector) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore)) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   StackHeavyCleanOneSector();
@@ -1367,30 +1419,30 @@
 
 TEST_F(KeyValueStoreTest, LargePartition) {
   if (CurrentTaskStackFree() < sizeof(KeyValueStore)) {
-    LOG_ERROR("Not enough stack for test, skipping");
+    PW_LOG_ERROR("Not enough stack for test, skipping");
     return;
   }
   large_test_partition.Erase(0, large_test_partition.GetSectorCount());
   KeyValueStore large_kvs(&large_test_partition);
   // Reset KVS
   large_kvs.Disable();
-  ASSERT_OK(large_kvs.Enable());
+  ASSERT_EQ(Status::OK, large_kvs.Enable());
 
   const uint8_t kValue1 = 0xDA;
   const uint8_t kValue2 = 0x12;
   uint8_t value[1];
-  ASSERT_OK(large_kvs.Put(keys[0], &kValue1, sizeof(kValue1)));
+  ASSERT_EQ(Status::OK, large_kvs.Put(keys[0], &kValue1, sizeof(kValue1)));
   EXPECT_EQ(large_kvs.KeyCount(), 1);
-  ASSERT_OK(large_kvs.Erase(keys[0]));
+  ASSERT_EQ(Status::OK, large_kvs.Erase(keys[0]));
   EXPECT_EQ(large_kvs.Get(keys[0], value, sizeof(value)), Status::NOT_FOUND);
-  ASSERT_OK(large_kvs.Put(keys[1], &kValue1, sizeof(kValue1)));
-  ASSERT_OK(large_kvs.Put(keys[2], &kValue2, sizeof(kValue2)));
-  ASSERT_OK(large_kvs.Erase(keys[1]));
-  EXPECT_OK(large_kvs.Get(keys[2], value, sizeof(value)));
+  ASSERT_EQ(Status::OK, large_kvs.Put(keys[1], &kValue1, sizeof(kValue1)));
+  ASSERT_EQ(Status::OK, large_kvs.Put(keys[2], &kValue2, sizeof(kValue2)));
+  ASSERT_EQ(Status::OK, large_kvs.Erase(keys[1]));
+  EXPECT_EQ(Status::OK, large_kvs.Get(keys[2], value, sizeof(value)));
   EXPECT_EQ(kValue2, value[0]);
   ASSERT_EQ(large_kvs.Get(keys[1], &value), Status::NOT_FOUND);
   EXPECT_EQ(large_kvs.KeyCount(), 1);
 }
 #endif  // USE_MEMORY_BUFFER
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/public/pw_kvs/assert.h b/pw_kvs/public/pw_kvs/assert.h
new file mode 100644
index 0000000..36f232b
--- /dev/null
+++ b/pw_kvs/public/pw_kvs/assert.h
@@ -0,0 +1,69 @@
+// Copyright 2020 The Pigweed Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+#pragma once
+
+#include <algorithm>
+#include <type_traits>
+
+// Compares the provided value to nullptr and returns it. This is intended to be
+// used as part of another statement.
+#define CHECK_NOTNULL(value) \
+  ::pw::log::CheckNotNull("", __LINE__, #value " != nullptr", value)
+
+// In release builds, DCHECK_NOTNULL simply passes along the value.
+// DCHECK_NOTNULL must not be used as a standalone expression, since the result
+// would be unused on release builds. Use DCHECK_NE instead.
+//#define DCHECK_NOTNULL(value) value
+
+#define DCHECK_NOTNULL(value) \
+  ::pw::log::DCheckNotNull("", __LINE__, #value " != nullptr", value)
+
+namespace pw::log {
+
+template <typename T>
+constexpr T CheckNotNull(const char* /* file */,
+                         unsigned /* line */,
+                         const char* /* message */,
+                         T&& value) {
+  static_assert(!std::is_null_pointer<T>(),
+                "CHECK_NOTNULL statements cannot be passed nullptr");
+  if (value == nullptr) {
+    std::exit(1);
+  }
+  return std::forward<T>(value);
+}
+
+// DCHECK_NOTNULL cannot be used in standalone expressions, so add a
+// [[nodiscard]] attribute to prevent this in debug builds. Standalone
+// DCHECK_NOTNULL statements in release builds trigger an unused-value warning.
+template <typename T>
+[[nodiscard]] constexpr T DCheckNotNull(const char* file,
+                                        unsigned line,
+                                        const char* message,
+                                        T&& value) {
+  return CheckNotNull<T>(file, line, message, std::forward<T>(value));
+}
+
+}  // namespace pw::log
+
+// Assert stubs
+#define DCHECK CHECK
+#define DCHECK_EQ CHECK_EQ
+
+#define CHECK(...)
+#define CHECK_EQ(...)
+#define CHECK_GE(...)
+#define CHECK_GT(...)
+#define CHECK_LE(...)
+#define CHECK_LT(...)
diff --git a/pw_kvs/public/pw_kvs/flash.h b/pw_kvs/public/pw_kvs/flash.h
index 5cb80cd..6eecea7 100644
--- a/pw_kvs/public/pw_kvs/flash.h
+++ b/pw_kvs/public/pw_kvs/flash.h
@@ -13,9 +13,9 @@
 // the License.
 #pragma once
 
-#include "pw_kvs/devices/flash_memory.h"
+#include "pw_kvs/flash_memory.h"
 
-namespace pw {
+namespace pw::kvs {
 
 // Writes a buffer which is not guaranteed to be aligned, pads remaining
 // bytes with 0.
@@ -30,4 +30,4 @@
                      FlashPartition::Address address,
                      uint16_t size);
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index 707f128..d62f794 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -14,14 +14,16 @@
 #pragma once
 
 #include <algorithm>
+#include <cinttypes>
+#include <cstring>
 
 #include "pw_kvs/assert.h"
-#include "pw_kvs/logging.h"
-#include "pw_kvs/peripherals/partition_table_entry.h"
-#include "pw_kvs/status.h"
-#include "pw_kvs/status_macros.h"
+#include "pw_kvs/partition_table_entry.h"
+#include "pw_log/log.h"
+#include "pw_status/status.h"
 
-namespace pw {
+namespace pw::kvs {
+
 class FlashMemory {
  public:
   // The flash address is in the range of: 0 to FlashSize.
@@ -39,6 +41,8 @@
         sector_start_(sector_start),
         erased_memory_content_(erased_memory_content) {}
 
+  virtual ~FlashMemory() = default;
+
   virtual Status Enable() = 0;
   virtual Status Disable() = 0;
   virtual bool IsEnabled() const = 0;
@@ -72,9 +76,7 @@
 
   // Convert an Address to an MCU pointer, this can be used for memory
   // mapped reads. Return NULL if the memory is not memory mapped.
-  virtual uint8_t* FlashAddressToMcuAddress(Address address) const {
-    return nullptr;
-  }
+  virtual uint8_t* FlashAddressToMcuAddress(Address) const { return nullptr; }
 
   // GetStartSector() is useful for FlashMemory instances where the
   // sector start is not 0. (ex.: cases where there are portions of flash
@@ -137,9 +139,7 @@
   bool IsEnabled() const override { return flash_.IsEnabled(); }
   Status SelfTest() override { return flash_.SelfTest(); }
 
-  Status Erase(Address flash_address, uint32_t num_sectors) override {
-    return Status::UNIMPLEMENTED;
-  }
+  Status Erase(Address, uint32_t) override { return Status::UNIMPLEMENTED; }
 
   Status Read(uint8_t* destination_ram_address,
               Address source_flash_address,
@@ -185,6 +185,8 @@
                       entry.partition_start_sector_index + 1),
         permission_(entry.partition_permission) {}
 
+  virtual ~FlashPartition() = default;
+
   // Erase num_sectors starting at a given address. Blocking call.
   // Address should be on a sector boundary.
   // Returns: OK, on success.
@@ -193,9 +195,14 @@
   //          PERMISSION_DENIED, if partition is read only.
   //          UNKNOWN, on HAL error
   virtual Status Erase(Address address, uint32_t num_sectors) {
-    RETURN_STATUS_IF(permission_ == PartitionPermission::kReadOnly,
-                     Status::PERMISSION_DENIED);
-    RETURN_IF_ERROR(CheckBounds(address, num_sectors * GetSectorSizeBytes()));
+    if (permission_ == PartitionPermission::kReadOnly) {
+      return Status::PERMISSION_DENIED;
+    }
+    if (Status status =
+            CheckBounds(address, num_sectors * GetSectorSizeBytes());
+        !status.ok()) {
+      return status;
+    }
     return flash_.Erase(PartitionToFlashAddress(address), num_sectors);
   }
 
@@ -207,7 +214,9 @@
   virtual Status Read(uint8_t* destination_ram_address,
                       Address source_flash_address,
                       uint32_t len) {
-    RETURN_IF_ERROR(CheckBounds(source_flash_address, len));
+    if (Status status = CheckBounds(source_flash_address, len); !status.ok()) {
+      return status;
+    }
     return flash_.Read(destination_ram_address,
                        PartitionToFlashAddress(source_flash_address),
                        len);
@@ -222,9 +231,13 @@
   virtual Status Write(Address destination_flash_address,
                        const uint8_t* source_ram_address,
                        uint32_t len) {
-    RETURN_STATUS_IF(permission_ == PartitionPermission::kReadOnly,
-                     Status::PERMISSION_DENIED);
-    RETURN_IF_ERROR(CheckBounds(destination_flash_address, len));
+    if (permission_ == PartitionPermission::kReadOnly) {
+      return Status::PERMISSION_DENIED;
+    }
+    if (Status status = CheckBounds(destination_flash_address, len);
+        !status.ok()) {
+      return status;
+    }
     return flash_.Write(PartitionToFlashAddress(destination_flash_address),
                         source_ram_address,
                         len);
@@ -243,24 +256,31 @@
     // function. Using 16 because it's the alignment of encrypted flash.
     const uint8_t kMaxAlignment = 16;
     // Relying on Read() to check address and len arguments.
-    RETURN_STATUS_IF(!is_erased, Status::INVALID_ARGUMENT);
+    if (!is_erased) {
+      return Status::INVALID_ARGUMENT;
+    }
     uint8_t alignment = GetAlignmentBytes();
-    RETURN_STATUS_IF(alignment > kMaxAlignment, Status::INVALID_ARGUMENT);
-    RETURN_STATUS_IF(kMaxAlignment % alignment, Status::INVALID_ARGUMENT);
-    RETURN_STATUS_IF(len % alignment, Status::INVALID_ARGUMENT);
+    if (alignment > kMaxAlignment || kMaxAlignment % alignment ||
+        len % alignment) {
+      return Status::INVALID_ARGUMENT;
+    }
 
     uint8_t buffer[kMaxAlignment];
     uint8_t erased_pattern_buffer[kMaxAlignment];
     size_t offset = 0;
-    memset(erased_pattern_buffer,
-           flash_.GetErasedMemoryContent(),
-           sizeof(erased_pattern_buffer));
+    std::memset(erased_pattern_buffer,
+                flash_.GetErasedMemoryContent(),
+                sizeof(erased_pattern_buffer));
     *is_erased = false;
     while (len > 0) {
       // Check earlier that len is aligned, no need to round up
       uint16_t read_size = std::min(static_cast<uint32_t>(sizeof(buffer)), len);
-      RETURN_IF_ERROR(Read(buffer, source_flash_address + offset, read_size));
-      if (memcmp(buffer, erased_pattern_buffer, read_size)) {
+      if (Status status =
+              Read(buffer, source_flash_address + offset, read_size);
+          !status.ok()) {
+        return status;
+      }
+      if (std::memcmp(buffer, erased_pattern_buffer, read_size)) {
         // Detected memory chunk is not entirely erased
         return Status::OK;
       }
@@ -301,8 +321,11 @@
  protected:
   Status CheckBounds(Address address, uint32_t len) const {
     if (address + len > GetSizeBytes()) {
-      LOG(ERROR) << "Attempted out-of-bound flash memory access (address:"
-                 << address << " length:" << len << ")";
+      PW_LOG_ERROR(
+          "Attempted out-of-bound flash memory access (address: %" PRIu32
+          " length: %zu)",
+          address,
+          len);
       return Status::INVALID_ARGUMENT;
     }
     return Status::OK;
@@ -331,14 +354,20 @@
         sector_count_(sector_count) {}
 
   Status Erase(Address address, uint32_t num_sectors) override {
-    RETURN_IF_ERROR(CheckBounds(address, num_sectors * GetSectorSizeBytes()));
+    if (Status status =
+            CheckBounds(address, num_sectors * GetSectorSizeBytes());
+        !status.ok()) {
+      return status;
+    }
     return partition_->Erase(ParentAddress(address), num_sectors);
   }
 
   Status Read(uint8_t* destination_ram_address,
               Address source_flash_address,
               uint32_t len) override {
-    RETURN_IF_ERROR(CheckBounds(source_flash_address, len));
+    if (Status status = CheckBounds(source_flash_address, len); !status.ok()) {
+      return status;
+    }
     return partition_->Read(
         destination_ram_address, ParentAddress(source_flash_address), len);
   }
@@ -346,7 +375,10 @@
   Status Write(Address destination_flash_address,
                const uint8_t* source_ram_address,
                uint32_t len) override {
-    RETURN_IF_ERROR(CheckBounds(destination_flash_address, len));
+    if (Status status = CheckBounds(destination_flash_address, len);
+        !status.ok()) {
+      return status;
+    }
     return partition_->Write(
         ParentAddress(destination_flash_address), source_ram_address, len);
   }
@@ -354,7 +386,9 @@
   Status IsChunkErased(Address source_flash_address,
                        uint32_t len,
                        bool* is_erased) override {
-    RETURN_IF_ERROR(CheckBounds(source_flash_address, len));
+    if (Status status = CheckBounds(source_flash_address, len); !status.ok()) {
+      return status;
+    }
     return partition_->IsChunkErased(
         ParentAddress(source_flash_address), len, is_erased);
   }
@@ -374,4 +408,4 @@
   const uint32_t sector_count_;
 };
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/public/pw_kvs/in_memory_fake_flash.h b/pw_kvs/public/pw_kvs/in_memory_fake_flash.h
index a67c770..d2ea67c 100644
--- a/pw_kvs/public/pw_kvs/in_memory_fake_flash.h
+++ b/pw_kvs/public/pw_kvs/in_memory_fake_flash.h
@@ -15,11 +15,10 @@
 
 #include <array>
 
-#include "pw_kvs/devices/flash_memory.h"
-#include "pw_kvs/status.h"
-#include "pw_kvs/status_macros.h"
+#include "pw_kvs/flash_memory.h"
+#include "pw_status/status.h"
 
-namespace pw {
+namespace pw::kvs {
 
 // This creates a buffer which mimics the behaviour of flash (requires erase,
 // before write, checks alignments, and is addressed in sectors).
@@ -40,12 +39,15 @@
   //          INVALID_ARGUMENT, if address or sector count is invalid.
   //          UNKNOWN, on HAL error
   Status Erase(Address addr, uint32_t num_sectors) override {
-    RETURN_STATUS_IF(addr % GetSectorSizeBytes() != 0,
-                     Status::INVALID_ARGUMENT);
-    RETURN_STATUS_IF(
-        addr / GetSectorSizeBytes() + num_sectors > GetSectorCount(),
-        Status::UNKNOWN);
-    RETURN_STATUS_IF(addr % GetAlignmentBytes() != 0, Status::INVALID_ARGUMENT);
+    if (addr % GetSectorSizeBytes() != 0) {
+      return Status::INVALID_ARGUMENT;
+    }
+    if (addr / GetSectorSizeBytes() + num_sectors > GetSectorCount()) {
+      return Status::UNKNOWN;
+    }
+    if (addr % GetAlignmentBytes() != 0) {
+      return Status::INVALID_ARGUMENT;
+    }
     memset(&buffer_[addr], 0xFF, GetSectorSizeBytes() * num_sectors);
     return Status::OK;
   }
@@ -57,9 +59,9 @@
   Status Read(uint8_t* dest_ram_addr,
               Address source_flash_addr,
               uint32_t len) override {
-    RETURN_STATUS_IF(
-        (source_flash_addr + len) >= GetSectorCount() * GetSizeBytes(),
-        Status::INVALID_ARGUMENT);
+    if ((source_flash_addr + len) >= GetSectorCount() * GetSizeBytes()) {
+      return Status::INVALID_ARGUMENT;
+    }
     memcpy(dest_ram_addr, &buffer_[source_flash_addr], len);
     return Status::OK;
   }
@@ -71,15 +73,16 @@
   Status Write(Address dest_flash_addr,
                const uint8_t* source_ram_addr,
                uint32_t len) override {
-    RETURN_STATUS_IF(
-        (dest_flash_addr + len) >= GetSectorCount() * GetSizeBytes(),
-        Status::INVALID_ARGUMENT);
-    RETURN_STATUS_IF(dest_flash_addr % GetAlignmentBytes() != 0,
-                     Status::INVALID_ARGUMENT);
-    RETURN_STATUS_IF(len % GetAlignmentBytes() != 0, Status::INVALID_ARGUMENT);
+    if ((dest_flash_addr + len) >= GetSectorCount() * GetSizeBytes() ||
+        dest_flash_addr % GetAlignmentBytes() != 0 ||
+        len % GetAlignmentBytes() != 0) {
+      return Status::INVALID_ARGUMENT;
+    }
     // Check in erased state
     for (unsigned i = 0; i < len; i++) {
-      RETURN_STATUS_IF(buffer_[dest_flash_addr + i] != 0xFF, Status::UNKNOWN);
+      if (buffer_[dest_flash_addr + i] != 0xFF) {
+        return Status::UNKNOWN;
+      }
     }
     memcpy(&buffer_[dest_flash_addr], source_ram_addr, len);
     return Status::OK;
@@ -89,4 +92,4 @@
   std::array<uint8_t, kSectorCount * kSectorSize> buffer_;
 };
 
-}  // namespace pw
+}  // namespace pw::kvs
diff --git a/pw_kvs/public/pw_kvs/key_value_store.h b/pw_kvs/public/pw_kvs/key_value_store.h
index dca6507..d9bb34f 100644
--- a/pw_kvs/public/pw_kvs/key_value_store.h
+++ b/pw_kvs/public/pw_kvs/key_value_store.h
@@ -16,17 +16,37 @@
 #include <algorithm>
 #include <type_traits>
 
-#include "pw_kvs/devices/flash_memory.h"
-#include "pw_kvs/logging.h"
-#include "pw_kvs/os/mutex.h"
-#include "pw_kvs/status.h"
+#include "pw_kvs/flash_memory.h"
+#include "pw_status/status.h"
 
-namespace pw {
+namespace cfg {
+
+// KVS requires a temporary buffer for some operations, this config allows
+// tuning the buffer size. This is a trade-off between a value which is large
+// and therefore requires more RAM, or having a value which is small which will
+// result in some operations taking longer, as the operations are broken into
+// smaller chunks.
+// NOTE: This value can not be smaller then the flash alignment, and it will
+//       round the size down to be a multiple of the flash alignment for all
+//       operations.
+inline constexpr size_t kKvsBufferSize = 64;
+
+// This represents the maximum amount of keys which can be in the KVS at any
+// given time.
+inline constexpr uint8_t kKvsMaxKeyCount = 50;
+
+// This is the maximum amount of sectors the KVS can operate on, an invalid
+// value will cause an error during enable.
+inline constexpr uint32_t kKvsMaxSectorCount = 20;
+
+}  // namespace cfg
+
+namespace pw::kvs {
 
 // This object is very large and should not be placed on the stack.
 class KeyValueStore {
  public:
-  KeyValueStore(FlashPartition* partition) : partition_(*partition) {}
+  constexpr KeyValueStore(FlashPartition* partition) : partition_(*partition) {}
 
   // Enable the KVS, scans the sectors of the partition for any current KVS
   // data. Erases and initializes any sectors which are not initialized.
@@ -39,7 +59,7 @@
     if (enabled_ == false) {
       return;
     }
-    os::MutexLock lock(&lock_);
+    // TODO: LOCK MUTEX
     enabled_ = false;
   }
 
@@ -67,9 +87,14 @@
   Status Get(const char* key, T* value) {
     static_assert(std::is_trivially_copyable<T>(), "KVS values must copyable");
     static_assert(!std::is_pointer<T>(), "KVS values cannot be pointers");
+
     uint16_t value_size = 0;
-    RETURN_IF_ERROR(GetValueSize(key, &value_size));
-    RETURN_STATUS_IF(value_size != sizeof(T), Status::INVALID_ARGUMENT);
+    if (Status status = GetValueSize(key, &value_size)) {
+      return status;
+    }
+    if (value_size != sizeof(T)) {
+      return Status::INVALID_ARGUMENT;
+    }
     return Get(key, value, sizeof(T));
   }
 
@@ -107,11 +132,11 @@
   // CleanAll cleans each sector which is currently marked for cleaning.
   // Note: if any data is invalid/corrupt it could be lost.
   Status CleanAll() {
-    os::MutexLock lock(&lock_);
+    // TODO: LOCK MUTEX
     return CleanAllInternal();
   }
   size_t PendingCleanCount() {
-    os::MutexLock lock(&lock_);
+    // TODO: LOCK MUTEX
     size_t ret = 0;
     for (size_t i = 0; i < SectorCount(); i++) {
       ret += sector_space_remaining_[i] == 0 ? 1 : 0;
@@ -345,7 +370,7 @@
   }
 
   FlashPartition& partition_;
-  os::Mutex lock_;
+  // TODO: MUTEX
   bool enabled_ = false;
   uint8_t alignment_bytes_ = 0;
   uint64_t next_sector_clean_order_ = 0;
@@ -353,7 +378,7 @@
   // Free space available in each sector, set to 0 when clean is pending/active
   uint32_t sector_space_remaining_[kSectorCountMax] = {0};
   uint64_t sector_clean_order_[kSectorCountMax] = {kSectorCleanNotPending};
-  KeyMap key_map_[kListCapacityMax] = {{{0}}};
+  KeyMap key_map_[kListCapacityMax] = {};
   KeyIndex map_size_ = 0;
 
   // +1 for nul-terminator since keys are stored as Length + Value and no nul
@@ -363,4 +388,4 @@
   uint8_t temp_buffer_[cfg::kKvsBufferSize] = {0};
 };
 
-}  // namespace pw
+}  // namespace pw::kvs