diff --git a/pw_kvs/BUILD b/pw_kvs/BUILD
index b5db383..a059c7b 100644
--- a/pw_kvs/BUILD
+++ b/pw_kvs/BUILD
@@ -25,6 +25,7 @@
 pw_cc_library(
     name = "pw_kvs",
     srcs = [
+        "alignment.cc",
         "checksum.cc",
         "flash_memory.cc",
         "format.cc",
@@ -33,10 +34,12 @@
         "pw_kvs_private/macros.h",
     ],
     hdrs = [
+        "public/pw_kvs/alignment.h",
         "public/pw_kvs/checksum.h",
         "public/pw_kvs/crc16_checksum.h",
         "public/pw_kvs/flash_memory.h",
         "public/pw_kvs/key_value_store.h",
+        "public/pw_kvs/output.h",
     ],
     includes = ["public"],
     deps = [
@@ -71,6 +74,16 @@
 )
 
 pw_cc_test(
+    name = "alignment_test",
+    srcs = [
+        "alignment_test.cc",
+    ],
+    deps = [
+        ":pw_kvs",
+    ],
+)
+
+pw_cc_test(
     name = "checksum_test",
     srcs = ["checksum_test.cc"],
     deps = [
diff --git a/pw_kvs/BUILD.gn b/pw_kvs/BUILD.gn
index 391e3fc..ee09468 100644
--- a/pw_kvs/BUILD.gn
+++ b/pw_kvs/BUILD.gn
@@ -22,11 +22,14 @@
 source_set("pw_kvs") {
   public_configs = [ ":default_config" ]
   public = [
+    "public/pw_kvs/alignment.h",
     "public/pw_kvs/checksum.h",
     "public/pw_kvs/flash_memory.h",
     "public/pw_kvs/key_value_store.h",
+    "public/pw_kvs/output.h",
   ]
   sources = [
+    "alignment.cc",
     "checksum.cc",
     "flash_memory.cc",
     "format.cc",
@@ -85,6 +88,7 @@
 
 pw_test_group("tests") {
   tests = [
+    ":alignment_test",
     ":checksum_test",
     ":entry_test",
     ":key_value_store_test",
@@ -92,6 +96,15 @@
   ]
 }
 
+pw_test("alignment_test") {
+  deps = [
+    ":pw_kvs",
+  ]
+  sources = [
+    "alignment_test.cc",
+  ]
+}
+
 pw_test("checksum_test") {
   deps = [
     ":crc16",
diff --git a/pw_kvs/alignment.cc b/pw_kvs/alignment.cc
new file mode 100644
index 0000000..c470a3c
--- /dev/null
+++ b/pw_kvs/alignment.cc
@@ -0,0 +1,65 @@
+// 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.
+
+#include "pw_kvs/alignment.h"
+
+namespace pw {
+
+Status AlignedWriter::Write(span<const std::byte> data) {
+  while (!data.empty()) {
+    size_t to_copy = std::min(write_size_ - bytes_in_buffer_, data.size());
+
+    std::memcpy(&buffer_[bytes_in_buffer_], data.data(), to_copy);
+    data = data.subspan(to_copy);
+    bytes_in_buffer_ += to_copy;
+
+    // If the buffer is full, write it out.
+    if (bytes_in_buffer_ == write_size_) {
+      if (Status status = output_.Write(buffer_, write_size_); !status.ok()) {
+        return status;
+      }
+
+      bytes_written_ += write_size_;
+      bytes_in_buffer_ = 0;
+    }
+  }
+
+  return Status::OK;
+}
+
+StatusWithSize AlignedWriter::Flush() {
+  static constexpr std::byte kPadByte = std::byte{0};
+
+  // If data remains in the buffer, pad it to the alignment size and flush the
+  // remaining data.
+  if (bytes_in_buffer_ != 0u) {
+    const size_t remaining_bytes = AlignUp(bytes_in_buffer_, alignment_bytes_);
+    std::memset(&buffer_[bytes_in_buffer_],
+                int(kPadByte),
+                remaining_bytes - bytes_in_buffer_);
+
+    if (Status status = output_.Write(buffer_, remaining_bytes); !status.ok()) {
+      return StatusWithSize(status, bytes_written_);
+    }
+
+    bytes_written_ += remaining_bytes;  // Include padding in the total.
+  }
+
+  const StatusWithSize result(bytes_written_);
+  bytes_written_ = 0;
+  bytes_in_buffer_ = 0;
+  return result;
+}
+
+}  // namespace pw
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
new file mode 100644
index 0000000..2b0771b
--- /dev/null
+++ b/pw_kvs/alignment_test.cc
@@ -0,0 +1,144 @@
+// 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.
+
+#include "pw_kvs/alignment.h"
+
+#include <string_view>
+
+#include "gtest/gtest.h"
+
+namespace pw::kvs {
+namespace {
+
+using std::byte;
+
+TEST(AlignUp, Zero) {
+  EXPECT_EQ(0u, AlignUp(0, 1));
+  EXPECT_EQ(0u, AlignUp(0, 2));
+  EXPECT_EQ(0u, AlignUp(0, 15));
+}
+
+TEST(AlignUp, Aligned) {
+  for (size_t i = 1; i < 130; ++i) {
+    EXPECT_EQ(i, AlignUp(i, i));
+    EXPECT_EQ(2 * i, AlignUp(2 * i, i));
+    EXPECT_EQ(3 * i, AlignUp(3 * i, i));
+  }
+}
+
+TEST(AlignUp, NonAligned_PowerOf2) {
+  EXPECT_EQ(32u, AlignUp(1, 32));
+  EXPECT_EQ(32u, AlignUp(31, 32));
+  EXPECT_EQ(64u, AlignUp(33, 32));
+  EXPECT_EQ(64u, AlignUp(45, 32));
+  EXPECT_EQ(64u, AlignUp(63, 32));
+  EXPECT_EQ(128u, AlignUp(127, 32));
+}
+
+TEST(AlignUp, NonAligned_NonPowerOf2) {
+  EXPECT_EQ(2u, AlignUp(1, 2));
+
+  EXPECT_EQ(15u, AlignUp(1, 15));
+  EXPECT_EQ(15u, AlignUp(14, 15));
+  EXPECT_EQ(30u, AlignUp(16, 15));
+}
+
+TEST(AlignDown, Zero) {
+  EXPECT_EQ(0u, AlignDown(0, 1));
+  EXPECT_EQ(0u, AlignDown(0, 2));
+  EXPECT_EQ(0u, AlignDown(0, 15));
+}
+
+TEST(AlignDown, Aligned) {
+  for (size_t i = 1; i < 130; ++i) {
+    EXPECT_EQ(i, AlignDown(i, i));
+    EXPECT_EQ(2 * i, AlignDown(2 * i, i));
+    EXPECT_EQ(3 * i, AlignDown(3 * i, i));
+  }
+}
+
+TEST(AlignDown, NonAligned_PowerOf2) {
+  EXPECT_EQ(0u, AlignDown(1, 32));
+  EXPECT_EQ(0u, AlignDown(31, 32));
+  EXPECT_EQ(32u, AlignDown(33, 32));
+  EXPECT_EQ(32u, AlignDown(45, 32));
+  EXPECT_EQ(32u, AlignDown(63, 32));
+  EXPECT_EQ(96u, AlignDown(127, 32));
+}
+
+TEST(AlignDown, NonAligned_NonPowerOf2) {
+  EXPECT_EQ(0u, AlignDown(1, 2));
+
+  EXPECT_EQ(0u, AlignDown(1, 15));
+  EXPECT_EQ(0u, AlignDown(14, 15));
+  EXPECT_EQ(15u, AlignDown(16, 15));
+}
+
+constexpr std::string_view kData =
+    "123456789_123456789_123456789_123456789_123456789_"   //  50
+    "123456789_123456789_123456789_123456789_123456789_";  // 100
+
+const span<const byte> kBytes = as_bytes(span(kData));
+
+TEST(AlignedWriter, VaryingLengthWriteCalls) {
+  static constexpr size_t kAlignment = 10;
+
+  OutputToFunction output([](span<const byte> data) {
+    EXPECT_EQ(data.size() % kAlignment, 0u);
+    EXPECT_EQ(kData.substr(0, data.size()),
+              std::string_view(reinterpret_cast<const char*>(data.data()),
+                               data.size()));
+    return StatusWithSize(data.size());
+  });
+
+  AlignedWriterBuffer<64> writer(kAlignment, output);
+
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(0, 1)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(1, 9)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(10, 11)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(21, 20)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(41, 9)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(50, 10)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(60, 30)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(90, 5)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(95, 0)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(95, 4)));
+  EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(99, 1)));
+
+  auto result = writer.Flush();
+  EXPECT_EQ(Status::OK, result.status());
+  EXPECT_EQ(kData.size(), result.size());
+}
+
+TEST(AlignedWriter, DestructorFlushes) {
+  static size_t called_with_bytes;
+
+  called_with_bytes = 0;
+
+  OutputToFunction output([](span<const byte> data) {
+    called_with_bytes += data.size();
+    return StatusWithSize(data.size());
+  });
+
+  {
+    AlignedWriterBuffer<64> writer(3, output);
+    writer.Write(as_bytes(span("What is this?")));
+    EXPECT_EQ(called_with_bytes, 0u);  // Buffer not full; no output yet.
+  }
+
+  EXPECT_EQ(called_with_bytes, AlignUp(sizeof("What is this?"), 3));
+}
+
+}  // namespace
+}  // namespace pw::kvs
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index ca5f5ff..a494c16 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -20,11 +20,18 @@
 
 #include "pw_kvs_private/macros.h"
 #include "pw_log/log.h"
+#include "pw_status/status_with_size.h"
 
 namespace pw::kvs {
 
 using std::byte;
 
+StatusWithSize FlashPartition::Output::Write(span<const byte> data) {
+  TRY(flash_.Write(address_, data));
+  address_ += data.size();
+  return StatusWithSize(data.size());
+}
+
 Status FlashPartition::Erase(Address address, size_t num_sectors) {
   if (permission_ == PartitionPermission::kReadOnly) {
     return Status::PERMISSION_DENIED;
@@ -47,54 +54,6 @@
   return flash_.Write(PartitionToFlashAddress(address), data);
 }
 
-StatusWithSize FlashPartition::WriteAligned(
-    const Address start_address, std::initializer_list<span<const byte>> data) {
-  byte buffer[64];  // TODO: Configure this?
-
-  Address address = start_address;
-  auto bytes_written = [&]() { return address - start_address; };
-
-  const size_t write_size = AlignDown(sizeof(buffer), alignment_bytes());
-  size_t bytes_in_buffer = 0;
-
-  for (span<const byte> chunk : data) {
-    while (!chunk.empty()) {
-      const size_t to_copy =
-          std::min(write_size - bytes_in_buffer, chunk.size());
-
-      std::memcpy(&buffer[bytes_in_buffer], chunk.data(), to_copy);
-      chunk = chunk.subspan(to_copy);
-      bytes_in_buffer += to_copy;
-
-      // If the buffer is full, write it out.
-      if (bytes_in_buffer == write_size) {
-        Status status = Write(address, span(buffer, write_size));
-        if (!status.ok()) {
-          return StatusWithSize(status, bytes_written());
-        }
-
-        address += write_size;
-        bytes_in_buffer = 0;
-      }
-    }
-  }
-
-  // If data remains in the buffer, pad it to the alignment size and flush
-  // the remaining data.
-  if (bytes_in_buffer != 0u) {
-    size_t remaining_write_size = AlignUp(bytes_in_buffer, alignment_bytes());
-    std::memset(
-        &buffer[bytes_in_buffer], 0, remaining_write_size - bytes_in_buffer);
-    if (Status status = Write(address, span(buffer, remaining_write_size));
-        !status.ok()) {
-      return StatusWithSize(status, bytes_written());
-    }
-    address += remaining_write_size;  // Include padding bytes in the total.
-  }
-
-  return StatusWithSize(bytes_written());
-}
-
 Status FlashPartition::IsRegionErased(Address source_flash_address,
                                       size_t length,
                                       bool* is_erased) {
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index b6b8e30..a30bc39 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -750,12 +750,13 @@
   Address address = NextWritableAddress(sector);
   DBG("Appending to address: %#zx", size_t(address));
 
-  // Handles writing multiple concatenated buffers, while breaking up the writes
-  // into alignment-sized blocks.
-  TRY_ASSIGN(
-      const size_t written,
-      partition_.WriteAligned(
-          address, {as_bytes(span(&header, 1)), as_bytes(span(key)), value}));
+  // Write multiple concatenated buffers and pad the results.
+  FlashPartition::Output flash(partition_, address);
+  TRY_ASSIGN(const size_t written,
+             AlignedWrite<32>(
+                 flash,
+                 header.alignment_bytes(),
+                 {as_bytes(span(&header, 1)), as_bytes(span(key)), value}));
 
   if (options_.verify_on_write) {
     TRY(header.VerifyChecksumInFlash(
diff --git a/pw_kvs/public/pw_kvs/alignment.h b/pw_kvs/public/pw_kvs/alignment.h
new file mode 100644
index 0000000..0829854
--- /dev/null
+++ b/pw_kvs/public/pw_kvs/alignment.h
@@ -0,0 +1,120 @@
+// 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 <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <utility>
+
+#include "pw_kvs/output.h"
+#include "pw_span/span.h"
+#include "pw_status/status_with_size.h"
+
+namespace pw {
+
+// Returns the value rounded down to the nearest multiple of alignment.
+constexpr size_t AlignDown(size_t value, size_t alignment) {
+  return (value / alignment) * alignment;
+}
+
+// Returns the value rounded up to the nearest multiple of alignment.
+constexpr size_t AlignUp(size_t value, size_t alignment) {
+  return (value + alignment - 1) / alignment * alignment;
+}
+
+// Returns the number of padding bytes required to align the provided length.
+constexpr size_t Padding(size_t length, size_t alignment) {
+  return AlignUp(length, alignment) - length;
+}
+
+// Class for managing aligned writes. Stores data in an intermediate buffer and
+// calls an output function with aligned data as the buffer becomes full. Any
+// bytes remaining in the buffer are written to the output when Flush() is
+// called or the AlignedWriter goes out of scope.
+class AlignedWriter {
+ public:
+  AlignedWriter(span<std::byte> buffer, size_t alignment_bytes, Output& writer)
+      : buffer_(buffer.data()),
+        write_size_(AlignDown(buffer.size(), alignment_bytes)),
+        alignment_bytes_(alignment_bytes),
+        output_(writer),
+        bytes_written_(0),
+        bytes_in_buffer_(0) {
+    // TODO(hepler): Add DCHECK to ensure that buffer.size() >= alignment_bytes.
+  }
+
+  ~AlignedWriter() { Flush(); }
+
+  // Writes bytes to the AlignedWriter. The output may be called if the internal
+  // buffer is filled.
+  Status Write(span<const std::byte> data);
+
+  Status Write(const void* data, size_t size) {
+    return Write(span(static_cast<const std::byte*>(data), size));
+  }
+
+  // Flush and reset the AlignedWriter. Any remaining bytes in the buffer are
+  // zero-padded to an alignment boundary and written to the output. Flush is
+  // automatically called when the AlignedWriter goes out of scope.
+  StatusWithSize Flush();
+
+ private:
+  std::byte* const buffer_;
+  const size_t write_size_;
+  const size_t alignment_bytes_;
+
+  Output& output_;
+  size_t bytes_written_;
+  size_t bytes_in_buffer_;
+};
+
+// Declares an AlignedWriter with a built-in buffer.
+template <size_t kBufferSize>
+class AlignedWriterBuffer : public AlignedWriter {
+ public:
+  template <typename... Args>
+  AlignedWriterBuffer(Args&&... aligned_writer_args)
+      : AlignedWriter(buffer_, std::forward<Args>(aligned_writer_args)...) {}
+
+ private:
+  std::byte buffer_[kBufferSize];
+};
+
+// Writes data from multiple buffers using an AlignedWriter.
+template <size_t kBufferSize>
+StatusWithSize AlignedWrite(Output& output,
+                            size_t alignment_bytes,
+                            span<const span<const std::byte>> data) {
+  AlignedWriterBuffer<kBufferSize> buffer(alignment_bytes, output);
+
+  for (const span<const std::byte>& chunk : data) {
+    if (Status status = buffer.Write(chunk); !status.ok()) {
+      return status;
+    }
+  }
+
+  return buffer.Flush();
+}
+
+// Calls AlignedWrite with an initializer list.
+template <size_t kBufferSize>
+StatusWithSize AlignedWrite(Output& output,
+                            size_t alignment_bytes,
+                            std::initializer_list<span<const std::byte>> data) {
+  return AlignedWrite<kBufferSize>(
+      output, alignment_bytes, span(data.begin(), data.size()));
+}
+
+}  // namespace pw
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index 3bc2a2b..a10af48 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -17,24 +17,11 @@
 #include <cstdint>
 #include <initializer_list>
 
+#include "pw_kvs/alignment.h"
 #include "pw_span/span.h"
 #include "pw_status/status.h"
 #include "pw_status/status_with_size.h"
 
-namespace pw {
-
-// TODO: These are general-purpose utility functions that should be moved
-//       elsewhere.
-constexpr size_t AlignDown(size_t value, size_t alignment) {
-  return (value / alignment) * alignment;
-}
-
-constexpr size_t AlignUp(size_t value, size_t alignment) {
-  return (value + alignment - 1) / alignment * alignment;
-}
-
-}  // namespace pw
-
 namespace pw::kvs {
 
 enum class PartitionPermission : bool {
@@ -137,6 +124,19 @@
   // The flash address is in the range of: 0 to PartitionSize.
   using Address = uint32_t;
 
+  // Implement Output for the Write method.
+  class Output final : public pw::Output {
+   public:
+    constexpr Output(FlashPartition& flash, FlashPartition::Address address)
+        : flash_(flash), address_(address) {}
+
+    StatusWithSize Write(span<const std::byte> data) override;
+
+   private:
+    FlashPartition& flash_;
+    FlashPartition::Address address_;
+  };
+
   constexpr FlashPartition(
       FlashMemory* flash,
       uint32_t start_sector_index,
@@ -185,10 +185,6 @@
   //          UNKNOWN, on HAL error
   virtual StatusWithSize Write(Address address, span<const std::byte> data);
 
-  // Returns the total number of bytes written, including any padding.
-  StatusWithSize WriteAligned(
-      Address start_address, std::initializer_list<span<const std::byte>> data);
-
   // Check to see if chunk of flash memory is erased. Address and len need to
   // be aligned with FlashMemory.
   // Returns: OK, on success.
diff --git a/pw_kvs/public/pw_kvs/output.h b/pw_kvs/public/pw_kvs/output.h
new file mode 100644
index 0000000..fae001f
--- /dev/null
+++ b/pw_kvs/public/pw_kvs/output.h
@@ -0,0 +1,89 @@
+// 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 <cstddef>
+#include <type_traits>
+
+#include "pw_span/span.h"
+#include "pw_status/status_with_size.h"
+
+namespace pw {
+namespace internal {
+
+template <typename T>
+struct FunctionTraits;
+
+template <typename T, typename ReturnType, typename... Args>
+struct FunctionTraits<ReturnType (T::*)(Args...)> {
+  using Class = T;
+  using Return = ReturnType;
+};
+
+}  // namespace internal
+
+// Writes bytes to an unspecified output. Provides a Write function that takes a
+// span of bytes and returns a Status.
+class Output {
+ public:
+  virtual StatusWithSize Write(span<const std::byte> data) = 0;
+
+  // Convenience wrapper for writing data from a pointer and length.
+  StatusWithSize Write(const void* data, size_t size_bytes) {
+    return Write(span(static_cast<const std::byte*>(data), size_bytes));
+  }
+
+ protected:
+  ~Output() = default;
+};
+
+// Output adapter that calls a method on a class with a span of bytes. If the
+// method returns void instead of the expected Status, Write always returns
+// Status::OK.
+template <auto kMethod>
+class OutputToMethod final : public Output {
+  using Class = typename internal::FunctionTraits<decltype(kMethod)>::Class;
+
+ public:
+  constexpr OutputToMethod(Class* object) : object_(*object) {}
+
+  StatusWithSize Write(span<const std::byte> data) override {
+    using Return = typename internal::FunctionTraits<decltype(kMethod)>::Return;
+
+    if constexpr (std::is_void_v<Return>) {
+      (object_.*kMethod)(data);
+      return StatusWithSize(data.size());
+    } else {
+      return (object_.*kMethod)(data);
+    }
+  }
+
+ private:
+  Class& object_;
+};
+
+// Output adapter that calls a free function.
+class OutputToFunction final : public Output {
+ public:
+  OutputToFunction(StatusWithSize (*function)(span<const std::byte>))
+      : function_(function) {}
+
+  StatusWithSize Write(span<const std::byte> data) override {
+    return function_(data);
+  }
+
+  StatusWithSize (*function_)(span<const std::byte>);
+};
+
+}  // namespace pw
diff --git a/pw_kvs/pw_kvs_private/format.h b/pw_kvs/pw_kvs_private/format.h
index 2e9094e..db42b12 100644
--- a/pw_kvs/pw_kvs_private/format.h
+++ b/pw_kvs/pw_kvs_private/format.h
@@ -20,6 +20,7 @@
 #include <cstring>
 #include <string_view>
 
+#include "pw_kvs/alignment.h"
 #include "pw_kvs/checksum.h"
 #include "pw_kvs/flash_memory.h"
 #include "pw_span/span.h"