diff --git a/pw_kvs/BUILD.gn b/pw_kvs/BUILD.gn
index c2552c8..205496c 100644
--- a/pw_kvs/BUILD.gn
+++ b/pw_kvs/BUILD.gn
@@ -50,6 +50,7 @@
   friend = [
     ":entry_test",
     ":key_value_store_test",
+    ":key_value_store_map_test",
   ]
 }
 
diff --git a/pw_kvs/debug_cli.cc b/pw_kvs/debug_cli.cc
index 8f5baeb..58eeac8 100644
--- a/pw_kvs/debug_cli.cc
+++ b/pw_kvs/debug_cli.cc
@@ -68,11 +68,10 @@
         char value[64] = {};
         if (StatusWithSize result = entry.Get(as_writable_bytes(span(value)));
             result.ok()) {
-          printf("%2d: %s='%s'\n", ++i, entry.key().data(), value);
+          printf("%2d: %s='%s'\n", ++i, entry.key(), value);
         } else {
-          printf("FAILED to Get key %s: %s\n",
-                 entry.key().data(),
-                 result.status().str());
+          printf(
+              "FAILED to Get key %s: %s\n", entry.key(), result.status().str());
         }
       }
       printf("---------------------------------------------- END CONTENTS\n");
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index c0cc9e6..458a12c 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -28,23 +28,28 @@
 Status Entry::Read(FlashPartition& partition, Address address, Entry* entry) {
   EntryHeader header;
   TRY(partition.Read(address, sizeof(header), &header));
-  *entry = Entry(&partition, address, header);
 
   if (partition.AppearsErased(as_bytes(span(&header.magic, 1)))) {
     return Status::NOT_FOUND;
   }
+  if (header.key_length_bytes > kMaxKeyLength) {
+    return Status::DATA_LOSS;
+  }
+
+  *entry = Entry(&partition, address, header);
   return Status::OK;
 }
 
-StatusWithSize Entry::ReadKey(FlashPartition& partition,
-                              Address address,
-                              size_t key_length,
-                              KeyBuffer& key) {
+Status Entry::ReadKey(FlashPartition& partition,
+                      Address address,
+                      size_t key_length,
+                      char* key) {
   if (key_length == 0u || key_length > kMaxKeyLength) {
-    return StatusWithSize(Status::DATA_LOSS);
+    return Status::DATA_LOSS;
   }
 
-  return partition.Read(address + sizeof(EntryHeader), key_length, key.data());
+  return partition.Read(address + sizeof(EntryHeader), key_length, key)
+      .status();
 }
 
 Entry::Entry(FlashPartition& partition,
@@ -131,7 +136,7 @@
   }
 
   if (algorithm == nullptr) {
-    return Status::OK;
+    return checksum() == 0 ? Status::OK : Status::DATA_LOSS;
   }
 
   // The checksum is calculated as if the header's checksum field were 0.
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 26c44a3..00a5bd9 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -14,45 +14,48 @@
 
 #include "pw_kvs_private/entry.h"
 
+#include <string_view>
+
 #include "gtest/gtest.h"
 #include "pw_kvs/alignment.h"
+#include "pw_kvs/crc16_checksum.h"
 #include "pw_kvs/flash_memory.h"
 #include "pw_kvs/in_memory_fake_flash.h"
+#include "pw_kvs_private/byte_utils.h"
+#include "pw_span/span.h"
 
 namespace pw::kvs {
 namespace {
 
-// TODO(hepler): expand these tests
-
-FakeFlashBuffer<128, 4> test_flash(16);
-FlashPartition test_partition(&test_flash, 0, test_flash.sector_count());
+using std::byte;
+using std::string_view;
 
 TEST(Entry, Size_RoundsUpToAlignment) {
+  FakeFlashBuffer<64, 2> flash(16);
+  FlashPartition partition(&flash, 0, flash.sector_count());
+
   for (size_t alignment_bytes = 1; alignment_bytes <= 4096; ++alignment_bytes) {
     const size_t align = AlignUp(alignment_bytes, Entry::kMinAlignmentBytes);
 
     for (size_t value : {size_t(0), align - 1, align, align + 1, 2 * align}) {
-      Entry entry = Entry::Valid(test_partition,
-                                 0,
-                                 9,
-                                 nullptr,
-                                 "k",
-                                 {nullptr, value},
-                                 alignment_bytes,
-                                 0);
+      Entry entry = Entry::Valid(
+          partition, 0, 9, nullptr, "k", {nullptr, value}, alignment_bytes, 0);
       ASSERT_EQ(AlignUp(sizeof(EntryHeader) + 1 /* key */ + value, align),
                 entry.size());
     }
 
-    Entry entry = Entry::Tombstone(
-        test_partition, 0, 9, nullptr, "k", alignment_bytes, 0);
+    Entry entry =
+        Entry::Tombstone(partition, 0, 9, nullptr, "k", alignment_bytes, 0);
     ASSERT_EQ(AlignUp(sizeof(EntryHeader) + 1 /* key */, align), entry.size());
   }
 }
 
 TEST(Entry, Construct_ValidEntry) {
+  FakeFlashBuffer<64, 2> flash(16);
+  FlashPartition partition(&flash, 0, flash.sector_count());
+
   auto entry = Entry::Valid(
-      test_partition, 1, 9, nullptr, "k", as_bytes(span("123")), 1, 9876);
+      partition, 1, 9, nullptr, "k", as_bytes(span("123")), 1, 9876);
 
   EXPECT_FALSE(entry.deleted());
   EXPECT_EQ(entry.magic(), 9u);
@@ -61,7 +64,10 @@
 }
 
 TEST(Entry, Construct_Tombstone) {
-  auto entry = Entry::Tombstone(test_partition, 1, 99, nullptr, "key", 1, 123);
+  FakeFlashBuffer<64, 2> flash(16);
+  FlashPartition partition(&flash, 0, flash.sector_count());
+
+  auto entry = Entry::Tombstone(partition, 1, 99, nullptr, "key", 1, 123);
 
   EXPECT_TRUE(entry.deleted());
   EXPECT_EQ(entry.magic(), 99u);
@@ -69,5 +75,192 @@
   EXPECT_EQ(entry.key_version(), 123u);
 }
 
+constexpr auto kHeader1 = ByteStr(
+    "\x0d\xf0\x0d\x60"  // magic
+    "\xC5\x65\x00\x00"  // checksum (CRC16)
+    "\x01"              // alignment
+    "\x05"              // key length
+    "\x06\x00"          // value size
+    "\x99\x98\x97\x96"  // version
+);
+
+constexpr auto kKey1 = ByteStr("key45");
+constexpr auto kValue1 = ByteStr("VALUE!");
+constexpr auto kPadding1 = ByteStr("\0\0\0\0\0");
+
+constexpr auto kEntry1 = AsBytes(kHeader1, kKey1, kValue1, kPadding1);
+
+class ValidEntryInFlash : public ::testing::Test {
+ protected:
+  ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) {
+    EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, &entry_));
+  }
+
+  FakeFlashBuffer<1024, 4> flash_;
+  FlashPartition partition_;
+  Entry entry_;
+};
+
+TEST_F(ValidEntryInFlash, PassesChecksumVerification) {
+  ChecksumCrc16 checksum;
+  EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash(&checksum));
+  EXPECT_EQ(Status::OK, entry_.VerifyChecksum(&checksum, "key45", kValue1));
+}
+
+TEST_F(ValidEntryInFlash, HeaderContents) {
+  EXPECT_EQ(entry_.magic(), 0x600DF00Du);
+  EXPECT_EQ(entry_.key_length(), 5u);
+  EXPECT_EQ(entry_.value_size(), 6u);
+  EXPECT_EQ(entry_.key_version(), 0x96979899u);
+  EXPECT_FALSE(entry_.deleted());
+}
+
+TEST_F(ValidEntryInFlash, ReadKey) {
+  Entry::KeyBuffer key = {};
+  auto result = entry_.ReadKey(key);
+
+  ASSERT_EQ(Status::OK, result.status());
+  EXPECT_EQ(result.size(), entry_.key_length());
+  EXPECT_STREQ(key.data(), "key45");
+}
+
+TEST_F(ValidEntryInFlash, ReadValue) {
+  char value[32] = {};
+  auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+
+  ASSERT_EQ(Status::OK, result.status());
+  EXPECT_EQ(result.size(), entry_.value_size());
+  EXPECT_STREQ(value, "VALUE!");
+}
+
+TEST_F(ValidEntryInFlash, ReadValue_ResourceExhaustedIfBufferFills) {
+  char value[3] = {};
+  auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+
+  ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+  EXPECT_EQ(3u, result.size());
+  EXPECT_EQ(value[0], 'V');
+  EXPECT_EQ(value[1], 'A');
+  EXPECT_EQ(value[2], 'L');
+}
+
+TEST(ValidEntry, Write) {
+  FakeFlashBuffer<1024, 4> flash;
+  FlashPartition partition(&flash);
+  ChecksumCrc16 checksum;
+
+  Entry entry = Entry::Valid(
+      partition, 53, 0x600DF00Du, &checksum, "key45", kValue1, 32, 0x96979899u);
+
+  auto result = entry.Write("key45", kValue1);
+  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(32u, result.size());
+  EXPECT_EQ(std::memcmp(&flash.buffer()[53], kEntry1.data(), kEntry1.size()),
+            0);
+}
+
+constexpr auto kHeader2 = ByteStr(
+    "\x0d\xf0\x0d\x60"  // magic
+    "\xd5\xf5\x00\x00"  // checksum (CRC16)
+    "\x00"              // alignment
+    "\x01"              // key length
+    "\xff\xff"          // value size
+    "\x00\x01\x02\x03"  // key version
+);
+
+constexpr auto kKeyAndPadding2 = ByteStr("K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
+
+class TombstoneEntryInFlash : public ::testing::Test {
+ protected:
+  TombstoneEntryInFlash()
+      : flash_(AsBytes(kHeader2, kKeyAndPadding2)), partition_(&flash_) {
+    EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, &entry_));
+  }
+
+  FakeFlashBuffer<1024, 4> flash_;
+  FlashPartition partition_;
+  Entry entry_;
+};
+
+TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) {
+  ChecksumCrc16 checksum;
+  EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash(&checksum));
+  EXPECT_EQ(Status::OK, entry_.VerifyChecksum(&checksum, "K", {}));
+}
+
+TEST_F(TombstoneEntryInFlash, HeaderContents) {
+  EXPECT_EQ(entry_.magic(), 0x600DF00Du);
+  EXPECT_EQ(entry_.key_length(), 1u);
+  EXPECT_EQ(entry_.value_size(), 0u);
+  EXPECT_EQ(entry_.key_version(), 0x03020100u);
+  EXPECT_TRUE(entry_.deleted());
+}
+
+TEST_F(TombstoneEntryInFlash, ReadKey) {
+  Entry::KeyBuffer key = {};
+  auto result = entry_.ReadKey(key);
+
+  ASSERT_EQ(Status::OK, result.status());
+  EXPECT_EQ(result.size(), entry_.key_length());
+  EXPECT_STREQ(key.data(), "K");
+}
+
+TEST_F(TombstoneEntryInFlash, ReadValue) {
+  char value[32] = {};
+  auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+
+  ASSERT_EQ(Status::OK, result.status());
+  EXPECT_EQ(0u, result.size());
+}
+
+TEST(TombstoneEntry, Write) {
+  FakeFlashBuffer<1024, 4> flash;
+  FlashPartition partition(&flash);
+  ChecksumCrc16 checksum;
+
+  Entry entry = Entry::Tombstone(
+      partition, 16, 0x600DF00Du, &checksum, "K", 16, 0x03020100);
+
+  auto result = entry.Write("K", {});
+  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(32u, result.size());
+  EXPECT_EQ(std::memcmp(&flash.buffer()[16],
+                        AsBytes(kHeader2, kKeyAndPadding2).data(),
+                        kEntry1.size()),
+            0);
+}
+
+TEST(Entry, Checksum_NoChecksumRequiresZero) {
+  FakeFlashBuffer<1024, 4> flash(kEntry1);
+  FlashPartition partition(&flash);
+  Entry entry;
+  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, &entry));
+
+  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash(nullptr));
+  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksum(nullptr, {}, {}));
+
+  std::memset(&flash.buffer()[4], 0, 4);  // set the checksum field to 0
+  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, &entry));
+  EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash(nullptr));
+  EXPECT_EQ(Status::OK, entry.VerifyChecksum(nullptr, {}, {}));
+}
+
+TEST(Entry, Checksum_ChecksPadding) {
+  FakeFlashBuffer<1024, 4> flash(
+      AsBytes(kHeader1, kKey1, kValue1, ByteStr("\0\0\0\0\1")));
+  FlashPartition partition(&flash);
+  Entry entry;
+  ASSERT_EQ(Status::OK, Entry::Read(partition, 0, &entry));
+
+  // Last byte in padding is a 1; should fail.
+  ChecksumCrc16 checksum;
+  EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash(&checksum));
+
+  // The in-memory verification fills in 0s for the padding.
+  EXPECT_EQ(Status::OK, entry.VerifyChecksum(&checksum, "key45", kValue1));
+
+  flash.buffer()[kEntry1.size() - 1] = byte{0};
+  EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash(&checksum));
+}
 }  // namespace
 }  // namespace pw::kvs
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 29fa778..b18d4f2 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -25,10 +25,17 @@
 #include "pw_log/log.h"
 
 namespace pw::kvs {
+namespace {
 
 using std::byte;
 using std::string_view;
 
+constexpr bool InvalidKey(std::string_view key) {
+  return key.empty() || (key.size() > Entry::kMaxKeyLength);
+}
+
+}  // namespace
+
 KeyValueStore::KeyValueStore(FlashPartition* partition,
                              const EntryHeaderFormat& format,
                              const Options& options)
@@ -148,7 +155,7 @@
   }
 
   // Read the key from flash & validate the entry (which reads the value).
-  KeyBuffer key_buffer;
+  Entry::KeyBuffer key_buffer;
   TRY_ASSIGN(size_t key_length, entry.ReadKey(key_buffer));
   const string_view key(key_buffer.data(), key_length);
 
@@ -393,13 +400,13 @@
 //
 Status KeyValueStore::FindKeyDescriptor(string_view key,
                                         const KeyDescriptor** result) const {
-  Entry::KeyBuffer key_buffer;
   const uint32_t hash = HashKey(key);
+  Entry::KeyBuffer key_buffer;
 
   for (auto& descriptor : key_descriptors_) {
     if (descriptor.key_hash == hash) {
       TRY(Entry::ReadKey(
-          partition_, descriptor.address, key.size(), key_buffer));
+          partition_, descriptor.address, key.size(), key_buffer.data()));
 
       if (key == string_view(key_buffer.data(), key.size())) {
         DBG("Found match for key hash 0x%08" PRIx32, hash);
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 542493d..43da122 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -30,6 +30,7 @@
 #include "pw_kvs/crc16_checksum.h"
 #include "pw_kvs/in_memory_fake_flash.h"
 #include "pw_kvs/key_value_store.h"
+#include "pw_kvs_private/entry.h"
 #include "pw_log/log.h"
 #include "pw_span/span.h"
 
@@ -114,8 +115,7 @@
 
         // Either add a new key or replace an existing one.
         if (empty() || random_int() % 2 == 0) {
-          key =
-              random_string(random_int() % (KeyValueStore::kMaxKeyLength + 1));
+          key = random_string(random_int() % (Entry::kMaxKeyLength + 1));
         } else {
           key = RandomPresentKey();
         }
@@ -197,7 +197,7 @@
 
       auto map_entry = map_.find(std::string(item.key()));
       if (map_entry == map_.end()) {
-        PW_LOG_CRITICAL("Entry %s missing from map", item.key().data());
+        PW_LOG_CRITICAL("Entry %s missing from map", item.key());
       } else if (map_entry != map_.end()) {
         EXPECT_EQ(map_entry->first, item.key());
 
@@ -218,7 +218,7 @@
 
     Status result = kvs_.Put(key, as_bytes(span(value)));
 
-    if (key.empty() || key.size() > KeyValueStore::kMaxKeyLength) {
+    if (key.empty() || key.size() > Entry::kMaxKeyLength) {
       EXPECT_EQ(Status::INVALID_ARGUMENT, result);
     } else if (map_.size() == KeyValueStore::kMaxEntries) {
       EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result);
@@ -248,7 +248,7 @@
 
     Status result = kvs_.Delete(key);
 
-    if (key.empty() || key.size() > KeyValueStore::kMaxKeyLength) {
+    if (key.empty() || key.size() > Entry::kMaxKeyLength) {
       EXPECT_EQ(Status::INVALID_ARGUMENT, result);
     } else if (map_.count(key) == 0) {
       EXPECT_EQ(Status::NOT_FOUND, result);
@@ -270,18 +270,18 @@
 
   void StartOperation(const std::string& operation, const std::string& key) {
     count_ += 1;
-    PW_LOG_CRITICAL(
+    PW_LOG_DEBUG(
         "[%3u] START %s for '%s'", count_, operation.c_str(), key.c_str());
   }
 
   void FinishOperation(const std::string& operation,
                        Status result,
                        const std::string& key) {
-    PW_LOG_CRITICAL("[%3u] FINISH %s <%s> for '%s'",
-                    count_,
-                    operation.c_str(),
-                    result.str(),
-                    key.c_str());
+    PW_LOG_DEBUG("[%3u] FINISH %s <%s> for '%s'",
+                 count_,
+                 operation.c_str(),
+                 result.str(),
+                 key.c_str());
   }
 
   bool empty() const { return map_.empty(); }
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 4b00ed5..1644e7c 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -374,7 +374,7 @@
   ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span(value))));
 
   for (KeyValueStore::Item entry : kvs_) {
-    EXPECT_STREQ(entry.key().data(), "kEy");  // Make sure null-terminated.
+    EXPECT_STREQ(entry.key(), "kEy");  // Make sure null-terminated.
 
     char buffer[sizeof(value)] = {};
     EXPECT_EQ(Status::OK, entry.Get(&buffer));
diff --git a/pw_kvs/public/pw_kvs/key_value_store.h b/pw_kvs/public/pw_kvs/key_value_store.h
index b29058d..b47041e 100644
--- a/pw_kvs/public/pw_kvs/key_value_store.h
+++ b/pw_kvs/public/pw_kvs/key_value_store.h
@@ -90,11 +90,6 @@
   static constexpr size_t kMaxUsableSectors = 256;
   static constexpr size_t kWorkingBufferSizeBytes = (4 * 1024);
 
-  // TODO: Remove the duplicate kMaxKeyLength and KeyBuffer definitions. These
-  // should be provided by the Entry class.
-  static constexpr size_t kMaxKeyLength = 0b111111;
-  using KeyBuffer = std::array<char, kMaxKeyLength + 1>;
-
   // In the future, will be able to provide additional EntryHeaderFormats for
   // backwards compatibility.
   KeyValueStore(FlashPartition* partition,
@@ -157,8 +152,8 @@
 
   class Item {
    public:
-    // Guaranteed to be null-terminated
-    std::string_view key() const { return key_buffer_.data(); }
+    // The key as a null-terminated string.
+    const char* key() const { return key_buffer_.data(); }
 
     StatusWithSize Get(span<std::byte> value_buffer) const {
       return kvs_.Get(key(), value_buffer);
@@ -178,7 +173,13 @@
     constexpr Item(const KeyValueStore& kvs) : kvs_(kvs), key_buffer_{} {}
 
     const KeyValueStore& kvs_;
-    KeyBuffer key_buffer_;
+
+    // TODO: Remove the duplicate kMaxKeyLength definition. This should be
+    // provided by the Entry class.
+    static constexpr size_t kMaxKeyLength = 0b111111;
+
+    // Buffer large enough for a null-terminated version of any valid key.
+    std::array<char, kMaxKeyLength + 1> key_buffer_;
   };
 
   class iterator {
@@ -280,10 +281,6 @@
 
   Status CheckOperation(std::string_view key) const;
 
-  static constexpr bool InvalidKey(std::string_view key) {
-    return key.empty() || (key.size() > kMaxKeyLength);
-  }
-
   Status FindKeyDescriptor(std::string_view key,
                            const KeyDescriptor** result) const;
 
diff --git a/pw_kvs/pw_kvs_private/entry.h b/pw_kvs/pw_kvs_private/entry.h
index c272886..4cae4bb 100644
--- a/pw_kvs/pw_kvs_private/entry.h
+++ b/pw_kvs/pw_kvs_private/entry.h
@@ -64,20 +64,22 @@
 
   using Address = FlashPartition::Address;
 
-  // Buffer capable of holding a null-terminated version of any valid key.
-  using KeyBuffer = std::array<char, kMaxKeyLength + 1>;
+  // Buffer capable of holding any valid key (without a null terminator);
+  using KeyBuffer = std::array<char, kMaxKeyLength>;
 
   // Returns flash partition Read error codes, or one of the following:
   //
   //          OK: successfully read the header and initialized the Entry
   //   NOT_FOUND: read the header, but the data appears to be erased
+  //   DATA_LOSS: read the header, but it contained invalid data
   //
   static Status Read(FlashPartition& partition, Address address, Entry* entry);
 
-  static StatusWithSize ReadKey(FlashPartition& partition,
-                                Address address,
-                                size_t key_length,
-                                KeyBuffer& key);
+  // Reads a key into a buffer, which must be at least key_length bytes.
+  static Status ReadKey(FlashPartition& partition,
+                        Address address,
+                        size_t key_length,
+                        char* key);
 
   // Creates a new Entry for a valid (non-deleted) entry.
   static Entry Valid(FlashPartition& partition,
@@ -123,8 +125,14 @@
 
   StatusWithSize Write(std::string_view key, span<const std::byte> value) const;
 
-  StatusWithSize ReadKey(KeyBuffer& key) const {
-    return ReadKey(partition(), address_, key_length(), key);
+  // Reads a key into a buffer, which must be large enough for a max-length key.
+  // If successful, the size is returned in the StatusWithSize. The key is not
+  // null terminated.
+  template <size_t kSize>
+  StatusWithSize ReadKey(std::array<char, kSize>& key) const {
+    static_assert(kSize >= kMaxKeyLength);
+    return StatusWithSize(
+        ReadKey(partition(), address_, key_length(), key.data()), key_length());
   }
 
   StatusWithSize ReadValue(span<std::byte> value) const;
@@ -149,6 +157,9 @@
   // Total size of this entry, including padding.
   size_t size() const { return AlignUp(content_size(), alignment_bytes()); }
 
+  // The length of the key in bytes. Keys are not null terminated.
+  size_t key_length() const { return header_.key_length_bytes; }
+
   // The size of the value, without padding. The size is 0 if this is a
   // tombstone entry.
   size_t value_size() const {
@@ -173,9 +184,6 @@
 
   uint32_t checksum() const { return header_.checksum; }
 
-  // The length of the key in bytes. Keys are not null terminated.
-  size_t key_length() const { return header_.key_length_bytes; }
-
   size_t alignment_bytes() const { return (header_.alignment_units + 1) * 16; }
 
   // The total size of the entry, excluding padding.