diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index c6ccca8..a245dec 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -296,6 +296,18 @@
   return entry_;
 }
 
+StatusWithSize KeyValueStore::ValueSize(std::string_view key) const {
+  TRY(InvalidOperation(key));
+
+  const KeyDescriptor* key_descriptor;
+  TRY(FindKeyDescriptor(key, &key_descriptor));
+
+  EntryHeader header;
+  TRY(ReadEntryHeader(*key_descriptor, &header));
+
+  return StatusWithSize(header.value_length());
+}
+
 Status KeyValueStore::ValidateEntryChecksum(const EntryHeader& header,
                                             string_view key,
                                             const KeyDescriptor& entry) const {
@@ -590,12 +602,12 @@
 
 Status KeyValueStore::VerifyEntry(SectorDescriptor* sector,
                                   KeyDescriptor* key_descriptor) {
+  // TODO: Remove this once checksums are fully implemented.
+  return Status::OK;
+
   if (entry_header_format_.checksum == nullptr) {
-    // TODO: Remove this once checksums are fully implemented.
     return Status::OK;
   }
-  return Status::UNIMPLEMENTED;
-
   // TODO: Implement me!
   (void)sector;
   (void)key_descriptor;
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 69ca2c2..8d979fa 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -1144,32 +1144,37 @@
   }
 }
 
-TEST_F(KeyValueStoreTest, DISABLED_GetValueSizeTests) {
-  constexpr uint16_t kSizeOfValueToFill = 20U;
-  constexpr uint8_t kKey0Pattern = 0xBA;
-  // Start off with disabled KVS
-  // kvs_.Disable();
+TEST_F(KeyValueStoreTest, ValueSize_Positive) {
+  constexpr auto kData = ByteArray('h', 'i', '!');
+  ASSERT_EQ(Status::OK, kvs_.Put("TheKey", kData));
 
-  // Try getting value when KVS is disabled, expect failure
-  EXPECT_EQ(kvs_.ValueSize(keys[0]).status(), Status::FAILED_PRECONDITION);
+  auto result = kvs_.ValueSize("TheKey");
 
-  // Reset KVS
-  test_partition.Erase(0, test_partition.sector_count());
-  ASSERT_EQ(Status::OK, kvs_.Init());
+  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(kData.size(), result.size());
+}
 
-  // Try some case that are expected to fail
-  ASSERT_EQ(kvs_.ValueSize(keys[0]).status(), Status::NOT_FOUND);
-  ASSERT_EQ(kvs_.ValueSize("").status(), Status::INVALID_ARGUMENT);
+TEST_F(KeyValueStoreTest, ValueSize_Zero) {
+  ASSERT_EQ(Status::OK, kvs_.Put("TheKey", as_bytes(span("123", 3))));
+  auto result = kvs_.ValueSize("TheKey");
 
-  // Add key[0] and test we get the right value size for it.
-  std::memset(buffer.data(), kKey0Pattern, kSizeOfValueToFill);
-  ASSERT_EQ(Status::OK,
-            kvs_.Put(keys[0], span(buffer.data(), kSizeOfValueToFill)));
-  ASSERT_EQ(kSizeOfValueToFill, kvs_.ValueSize(keys[0]).size());
+  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(3u, result.size());
+}
 
-  // Verify after erase key is not found
-  ASSERT_EQ(Status::OK, kvs_.Delete(keys[0]));
-  ASSERT_EQ(kvs_.ValueSize(keys[0]).status(), Status::NOT_FOUND);
+TEST_F(KeyValueStoreTest, ValueSize_InvalidKey) {
+  EXPECT_EQ(Status::INVALID_ARGUMENT, kvs_.ValueSize("").status());
+}
+
+TEST_F(KeyValueStoreTest, ValueSize_MissingKey) {
+  EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize("Not in there").status());
+}
+
+TEST_F(KeyValueStoreTest, DISABLED_ValueSize_DeletedKey) {
+  ASSERT_EQ(Status::OK, kvs_.Put("TheKey", as_bytes(span("123", 3))));
+  ASSERT_EQ(Status::OK, kvs_.Delete("TheKey"));
+
+  EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize("TheKey").status());
 }
 
 #if 0  // TODO: not CanFitEntry function yet
diff --git a/pw_kvs/public/pw_kvs/key_value_store.h b/pw_kvs/public/pw_kvs/key_value_store.h
index 6efa73b..a6cf7c0 100644
--- a/pw_kvs/public/pw_kvs/key_value_store.h
+++ b/pw_kvs/public/pw_kvs/key_value_store.h
@@ -96,8 +96,6 @@
     static_assert(std::is_trivially_copyable<T>(), "KVS values must copyable");
     static_assert(!std::is_pointer<T>(), "KVS values cannot be pointers");
 
-    // TODO: Re-enable this check once we are further along.
-#if 0
     // Ensure that the size of the stored value matches the size of the type.
     // Otherwise, report error. This check avoids potential memory corruption.
     StatusWithSize result = ValueSize(key);
@@ -107,7 +105,6 @@
     if (result.size() != sizeof(T)) {
       return Status::INVALID_ARGUMENT;
     }
-#endif
     return Get(key, as_writable_bytes(span(value, 1))).status();
   }
 
@@ -123,12 +120,7 @@
 
   Status Delete(std::string_view key);
 
-  StatusWithSize ValueSize(std::string_view key) const {
-    // TODO: Implement this! For now, just accept whatever size.
-    // return Status::OK;
-    (void)key;
-    return Status::UNIMPLEMENTED;
-  }
+  StatusWithSize ValueSize(std::string_view key) const;
 
   void LogDebugInfo();