diff --git a/docs/specs/file-format.md b/docs/specs/file-format.md
index 425294f2d99..97cc0dbf694 100644
--- a/docs/specs/file-format.md
+++ b/docs/specs/file-format.md
@@ -52,6 +52,13 @@ The postscript contains the locations of:
 2. a `layout` segment containing the root `Layout`
 3. a `statistics` segment containing file-level per-field statistics (e.g., minima and maxima of each field/column, for whole-file pruning)
 4. a `footer` segment containing a dictionary-encoded _segment map_, and other shared configuration such as compression and encryption schemes
+5. an optional `metadata` segment holding user-defined file-level metadata (a `FileMetadata` flatbuffer of opaque byte values keyed by unique, non-empty UTF-8 strings)
+
+The postscript carries a single locator (offset, length, and alignment) for the metadata segment
+when the file has one; a file written without user metadata (and any file predating this feature)
+carries none. The segment may live anywhere in the file. Readers do not load the metadata by
+default; an opt-in read resolves the one locator, fetching the segment without reading the
+intervening file contents when it lies outside the initial file-tail read.
 
 :::{literalinclude} ../../vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
 :start-after: [postscript]
diff --git a/vortex-buffer/src/alignment.rs b/vortex-buffer/src/alignment.rs
index ad5c51761bd..d410c7333c1 100644
--- a/vortex-buffer/src/alignment.rs
+++ b/vortex-buffer/src/alignment.rs
@@ -111,13 +111,32 @@ impl Alignment {
             .vortex_expect("alignment is a power of 2 within usize, so its exponent fits in u8")
     }
 
+    /// Try to create an alignment from its log2 exponent.
+    ///
+    /// Returns an error when the exponent cannot be represented by a `usize` alignment.
+    #[inline]
+    pub fn try_from_exponent(exponent: u8) -> Result<Self, VortexError> {
+        let alignment = 1usize.checked_shl(u32::from(exponent)).ok_or_else(|| {
+            vortex_err!(
+                "Alignment exponent {exponent} must be less than {}",
+                usize::BITS
+            )
+        })?;
+        Ok(Self::new(alignment))
+    }
+
     /// Create from the log2 exponent of the alignment.
     ///
     /// ## Panics
     ///
-    /// Panics if `1 << exponent` overflows `usize`.
+    /// Panics if `1 << exponent` overflows `usize`. Use [`Self::try_from_exponent`] when parsing
+    /// untrusted input.
     #[inline]
     pub const fn from_exponent(exponent: u8) -> Self {
+        assert!(
+            (exponent as u32) < usize::BITS,
+            "Alignment exponent must fit in usize"
+        );
         Self::new(1 << exponent)
     }
 }
@@ -214,6 +233,13 @@ mod test {
         assert_eq!(Alignment::from_exponent(10), alignment);
     }
 
+    #[test]
+    fn invalid_alignment_exponent() {
+        let error = Alignment::try_from_exponent(u8::try_from(usize::BITS).unwrap())
+            .expect_err("an exponent as wide as usize must be rejected");
+        assert!(error.to_string().contains("must be less than"));
+    }
+
     #[test]
     fn is_aligned_to() {
         assert!(Alignment::new(1).is_aligned_to(Alignment::new(1)));
diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs
index c9a71f85c55..df7a8e35891 100644
--- a/vortex-file/src/file.rs
+++ b/vortex-file/src/file.rs
@@ -15,6 +15,7 @@ use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldMask;
 use vortex_array::expr::Expression;
+use vortex_buffer::ByteBuffer;
 use vortex_error::VortexResult;
 use vortex_layout::LayoutReader;
 use vortex_layout::scan::layout::LayoutReaderDataSource;
@@ -23,6 +24,7 @@ use vortex_layout::scan::split_by::SplitBy;
 use vortex_layout::segments::SegmentSource;
 use vortex_scan::DataSourceRef;
 use vortex_session::VortexSession;
+use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::FileStatistics;
 use crate::footer::Footer;
@@ -42,6 +44,8 @@ pub struct VortexFile {
     segment_source: Arc<dyn SegmentSource>,
     /// The Vortex session used to open this file.
     session: VortexSession,
+    /// User-defined metadata values resolved for this file open.
+    metadata: Arc<HashMap<String, ByteBuffer>>,
     /// None id LayoutReader caching is turned off
     layout_reader_cache: Option<OnceLock<Arc<dyn LayoutReader>>>,
 }
@@ -78,10 +82,16 @@ impl VortexFile {
             footer,
             segment_source,
             session,
+            metadata: Arc::new(HashMap::new()),
             layout_reader_cache: None,
         }
     }
 
+    pub(crate) fn with_metadata(mut self, metadata: Arc<HashMap<String, ByteBuffer>>) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
     /// Enable layout reader caching.
     ///
     /// Repeated calls to [`layout_reader`](Self::layout_reader), [`scan`](Self::scan), and
@@ -91,6 +101,7 @@ impl VortexFile {
             footer: self.footer,
             segment_source: self.segment_source,
             session: self.session,
+            metadata: self.metadata,
             layout_reader_cache: Some(OnceLock::new()),
         }
     }
@@ -117,6 +128,22 @@ impl VortexFile {
         self.footer.statistics()
     }
 
+    /// Returns the user-defined metadata segments loaded for this file.
+    ///
+    /// Metadata is only loaded when requested during open. Iteration order is unspecified.
+    pub fn metadata_segments(&self) -> impl Iterator<Item = (&str, &ByteBuffer)> {
+        self.metadata
+            .iter()
+            .map(|(key, metadata)| (key.as_str(), metadata))
+    }
+
+    /// Returns the loaded user-defined metadata segment for the given key.
+    ///
+    /// Returns `None` when the key is absent or metadata was not loaded.
+    pub fn metadata_segment(&self, key: &str) -> Option<&ByteBuffer> {
+        self.metadata.get(key)
+    }
+
     /// Create a new segment source for reading from the file.
     ///
     /// This may spawn a background I/O driver that will exit when the returned segment source
diff --git a/vortex-file/src/footer/deserializer.rs b/vortex-file/src/footer/deserializer.rs
index a0f12e85c8a..2b7014a3399 100644
--- a/vortex-file/src/footer/deserializer.rs
+++ b/vortex-file/src/footer/deserializer.rs
@@ -18,6 +18,7 @@ use crate::Footer;
 use crate::MAGIC_BYTES;
 use crate::VERSION;
 use crate::footer::FileStatistics;
+use crate::footer::SegmentSpec;
 use crate::footer::postscript::Postscript;
 use crate::footer::postscript::PostscriptSegment;
 
@@ -165,14 +166,47 @@ impl FooterDeserializer {
                 )
             })
             .transpose()?;
+        // Validate the optional metadata locator here; values are resolved later, on demand. It
+        // never widens the required initial read.
+        let metadata_segment = match &postscript.metadata {
+            None => None,
+            Some(segment) => {
+                let spec = SegmentSpec {
+                    offset: segment.offset,
+                    length: segment.length,
+                    alignment: segment.alignment,
+                };
+                let end = spec
+                    .offset
+                    .checked_add(u64::from(spec.length))
+                    .ok_or_else(|| vortex_err!("Metadata segment range overflowed u64"))?;
+                if end > file_size {
+                    vortex_bail!(
+                        "Metadata segment range {}..{} exceeds file size {}",
+                        spec.offset,
+                        end,
+                        file_size
+                    );
+                }
+                let offset = usize::try_from(spec.offset)?;
+                if !spec.alignment.is_offset_aligned(offset) {
+                    vortex_bail!(
+                        "Metadata segment offset {} is not aligned to {}",
+                        spec.offset,
+                        spec.alignment
+                    );
+                }
+                Some(spec)
+            }
+        };
 
         Ok(DeserializeStep::Done(self.parse_footer(
             initial_offset,
             &self.buffer,
-            &postscript.footer,
-            &postscript.layout,
+            postscript,
             dtype,
             file_stats,
+            metadata_segment,
         )?))
     }
 
@@ -257,22 +291,31 @@ impl FooterDeserializer {
         &self,
         initial_offset: u64,
         initial_read: &[u8],
-        footer_segment: &PostscriptSegment,
-        layout_segment: &PostscriptSegment,
+        postscript: &Postscript,
         dtype: DType,
         file_stats: Option<FileStatistics>,
+        metadata_segment: Option<SegmentSpec>,
     ) -> VortexResult<Footer> {
+        let footer_segment = &postscript.footer;
         let footer_offset = usize::try_from(footer_segment.offset - initial_offset)?;
         let footer_bytes = FlatBuffer::copy_from(
             &initial_read[footer_offset..footer_offset + (footer_segment.length as usize)],
         );
 
+        let layout_segment = &postscript.layout;
         let layout_offset = usize::try_from(layout_segment.offset - initial_offset)?;
         let layout_bytes = FlatBuffer::copy_from(
             &initial_read[layout_offset..layout_offset + (layout_segment.length as usize)],
         );
 
-        Footer::from_flatbuffer(footer_bytes, layout_bytes, dtype, file_stats, &self.session)
+        Footer::from_flatbuffer(
+            footer_bytes,
+            layout_bytes,
+            dtype,
+            file_stats,
+            metadata_segment,
+            &self.session,
+        )
     }
 }
 
diff --git a/vortex-file/src/footer/metadata.rs b/vortex-file/src/footer/metadata.rs
new file mode 100644
index 00000000000..f0194d3ada8
--- /dev/null
+++ b/vortex-file/src/footer/metadata.rs
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! User-defined file-level metadata: opaque byte values keyed by unique, non-empty strings,
+//! serialized into a single [`fb::FileMetadata`] segment that the postscript locates by offset.
+
+use flatbuffers::FlatBufferBuilder;
+use flatbuffers::WIPOffset;
+use flatbuffers::root;
+use vortex_buffer::ByteBuffer;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_flatbuffers::FlatBufferRoot;
+use vortex_flatbuffers::WriteFlatBuffer;
+use vortex_flatbuffers::footer as fb;
+use vortex_utils::aliases::hash_map::HashMap;
+
+/// User-defined file-level metadata, serialized into a single Vortex file segment.
+pub(crate) struct FileMetadata {
+    /// Entries sorted by key so the serialized bytes are deterministic.
+    entries: Vec<(String, ByteBuffer)>,
+}
+
+impl FileMetadata {
+    /// Build [`FileMetadata`] from a keyed map of opaque values.
+    pub(crate) fn new(metadata: HashMap<String, ByteBuffer>) -> Self {
+        let mut entries: Vec<(String, ByteBuffer)> = metadata.into_iter().collect();
+        entries.sort_unstable_by(|(left, _), (right, _)| left.cmp(right));
+        Self { entries }
+    }
+
+    /// Parse a metadata segment into a keyed map, copying values out so the file bytes aren't pinned.
+    pub(crate) fn parse(bytes: &[u8]) -> VortexResult<HashMap<String, ByteBuffer>> {
+        let fb = root::<fb::FileMetadata>(bytes)?;
+        let mut map = HashMap::default();
+        if let Some(entries) = fb.entries() {
+            for entry in entries.iter() {
+                let key = entry.key();
+                if key.is_empty() {
+                    vortex_bail!("File metadata contains an empty key");
+                }
+                let value = ByteBuffer::copy_from(entry.value().bytes());
+                if map.insert(key.to_string(), value).is_some() {
+                    vortex_bail!("File metadata contains duplicate key {key}");
+                }
+            }
+        }
+        Ok(map)
+    }
+}
+
+impl FlatBufferRoot for FileMetadata {}
+
+impl WriteFlatBuffer for FileMetadata {
+    type Target<'a> = fb::FileMetadata<'a>;
+
+    fn write_flatbuffer<'fb>(
+        &self,
+        fbb: &mut FlatBufferBuilder<'fb>,
+    ) -> VortexResult<WIPOffset<Self::Target<'fb>>> {
+        let entries = self
+            .entries
+            .iter()
+            .map(|(key, value)| {
+                let key = fbb.create_string(key);
+                let value = fbb.create_vector(value.as_slice());
+                fb::MetadataEntry::create(
+                    fbb,
+                    &fb::MetadataEntryArgs {
+                        key: Some(key),
+                        value: Some(value),
+                    },
+                )
+            })
+            .collect::<Vec<_>>();
+        let entries = fbb.create_vector(entries.as_slice());
+        Ok(fb::FileMetadata::create(
+            fbb,
+            &fb::FileMetadataArgs {
+                entries: Some(entries),
+            },
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_flatbuffers::WriteFlatBufferExt;
+
+    use super::*;
+
+    fn metadata<const N: usize>(entries: [(&str, &[u8]); N]) -> FileMetadata {
+        FileMetadata::new(
+            entries
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), ByteBuffer::copy_from(value)))
+                .collect(),
+        )
+    }
+
+    #[test]
+    fn roundtrip_is_deterministic() -> VortexResult<()> {
+        // Insertion order must not affect the serialized bytes (entries are sorted by key).
+        let forward =
+            metadata([("a", b"alpha"), ("b", b""), ("c", b"gamma")]).write_flatbuffer_bytes()?;
+        let reverse =
+            metadata([("c", b"gamma"), ("b", b""), ("a", b"alpha")]).write_flatbuffer_bytes()?;
+        assert_eq!(forward.as_slice(), reverse.as_slice());
+
+        let parsed = FileMetadata::parse(&forward)?;
+        assert_eq!(parsed.len(), 3);
+        assert_eq!(parsed["a"].as_slice(), b"alpha");
+        assert!(parsed["b"].is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn parse_rejects_empty_key() -> VortexResult<()> {
+        let bytes = metadata([("", b"value")]).write_flatbuffer_bytes()?;
+        let error = FileMetadata::parse(&bytes).expect_err("empty key must be rejected");
+        assert!(error.to_string().contains("empty key"));
+        Ok(())
+    }
+}
diff --git a/vortex-file/src/footer/mod.rs b/vortex-file/src/footer/mod.rs
index f4bf7e19760..a9ef3744d0c 100644
--- a/vortex-file/src/footer/mod.rs
+++ b/vortex-file/src/footer/mod.rs
@@ -10,6 +10,7 @@
 //! the structured Rust representation and serializer/deserializer state machine.
 mod file_layout;
 mod file_statistics;
+mod metadata;
 mod postscript;
 mod segment;
 
@@ -22,6 +23,7 @@ pub use deserializer::*;
 pub use file_statistics::FileStatistics;
 use flatbuffers::root;
 use itertools::Itertools;
+pub(crate) use metadata::FileMetadata;
 pub use segment::*;
 use vortex_array::ArrayId;
 use vortex_array::dtype::DType;
@@ -43,6 +45,8 @@ pub struct Footer {
     root_layout: LayoutRef,
     segments: Arc<[SegmentSpec]>,
     statistics: Option<FileStatistics>,
+    // Locator for the optional user-defined metadata segment, if the file has one.
+    metadata_segment: Option<SegmentSpec>,
     // The specific arrays used within the file, in the order they were registered.
     array_read_ctx: ReadContext,
     // The approximate size of the footer in bytes, used for caching and memory management.
@@ -60,6 +64,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
+            metadata_segment: None,
             array_read_ctx,
             approx_byte_size: None,
         }
@@ -76,6 +81,7 @@ impl Footer {
         layout_bytes: FlatBuffer,
         dtype: DType,
         statistics: Option<FileStatistics>,
+        metadata_segment: Option<SegmentSpec>,
         session: &VortexSession,
     ) -> VortexResult<Self> {
         let approx_byte_size = footer_bytes.len() + layout_bytes.len();
@@ -126,6 +132,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
+            metadata_segment,
             array_read_ctx,
             approx_byte_size: Some(approx_byte_size),
         })
@@ -146,6 +153,27 @@ impl Footer {
         self.statistics.as_ref()
     }
 
+    /// Returns the locator for the file's user-defined metadata segment, if any.
+    ///
+    /// Present whenever the file was written with metadata; the values are resolved only on
+    /// [`VortexOpenOptions::include_metadata`](crate::VortexOpenOptions::include_metadata).
+    pub fn metadata_segment(&self) -> Option<&SegmentSpec> {
+        self.metadata_segment.as_ref()
+    }
+
+    pub(crate) fn with_metadata_segment(mut self, metadata_segment: Option<SegmentSpec>) -> Self {
+        self.metadata_segment = metadata_segment;
+        self
+    }
+
+    pub(crate) fn segment_specs_with_metadata(&self) -> Arc<[SegmentSpec]> {
+        self.segments
+            .iter()
+            .copied()
+            .chain(self.metadata_segment)
+            .collect()
+    }
+
     /// Returns the [`DType`] of the file.
     pub fn dtype(&self) -> &DType {
         self.root_layout.dtype()
diff --git a/vortex-file/src/footer/postscript.rs b/vortex-file/src/footer/postscript.rs
index 105a25cf287..61642e628da 100644
--- a/vortex-file/src/footer/postscript.rs
+++ b/vortex-file/src/footer/postscript.rs
@@ -20,6 +20,8 @@ pub(crate) struct Postscript {
     pub(crate) layout: PostscriptSegment,
     pub(crate) statistics: Option<PostscriptSegment>,
     pub(crate) footer: PostscriptSegment,
+    /// Locator for the optional user-defined metadata segment (a `FileMetadata` flatbuffer).
+    pub(crate) metadata: Option<PostscriptSegment>,
 }
 
 impl FlatBufferRoot for Postscript {}
@@ -43,6 +45,11 @@ impl WriteFlatBuffer for Postscript {
             .map(|ps| ps.write_flatbuffer(fbb))
             .transpose()?;
         let footer = self.footer.write_flatbuffer(fbb)?;
+        let metadata = self
+            .metadata
+            .as_ref()
+            .map(|ps| ps.write_flatbuffer(fbb))
+            .transpose()?;
         Ok(fb::Postscript::create(
             fbb,
             &fb::PostscriptArgs {
@@ -50,6 +57,7 @@ impl WriteFlatBuffer for Postscript {
                 layout: Some(layout),
                 statistics,
                 footer: Some(footer),
+                metadata,
             },
         ))
     }
@@ -79,6 +87,10 @@ impl ReadFlatBuffer for Postscript {
                 &fb.footer()
                     .ok_or_else(|| vortex_err!("Postscript missing footer segment"))?,
             )?,
+            metadata: fb
+                .metadata()
+                .map(|ps| PostscriptSegment::read_flatbuffer(&ps))
+                .transpose()?,
         })
     }
 }
@@ -121,7 +133,42 @@ impl ReadFlatBuffer for PostscriptSegment {
         Ok(PostscriptSegment {
             offset: fb.offset(),
             length: fb.length(),
-            alignment: Alignment::from_exponent(fb.alignment_exponent()),
+            alignment: Alignment::try_from_exponent(fb.alignment_exponent())?,
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_flatbuffers::ReadFlatBuffer;
+    use vortex_flatbuffers::WriteFlatBufferExt;
+
+    use super::*;
+
+    fn segment(offset: u64) -> PostscriptSegment {
+        PostscriptSegment {
+            offset,
+            length: 1,
+            alignment: Alignment::none(),
+        }
+    }
+
+    #[test]
+    fn roundtrip_with_metadata_locator() -> VortexResult<()> {
+        let bytes = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: Some(segment(2)),
+        }
+        .write_flatbuffer_bytes()?;
+
+        let postscript = Postscript::read_flatbuffer_bytes(&bytes)?;
+        let metadata = postscript
+            .metadata
+            .expect("metadata locator should round-trip");
+        assert_eq!(metadata.offset, 2);
+        Ok(())
+    }
+}
diff --git a/vortex-file/src/footer/segment.rs b/vortex-file/src/footer/segment.rs
index 8dcb7d1802b..1aeda2edd6a 100644
--- a/vortex-file/src/footer/segment.rs
+++ b/vortex-file/src/footer/segment.rs
@@ -43,7 +43,7 @@ impl TryFrom<&fb::SegmentSpec> for SegmentSpec {
         Ok(Self {
             offset: value.offset(),
             length: value.length(),
-            alignment: Alignment::from_exponent(value.alignment_exponent()),
+            alignment: Alignment::try_from_exponent(value.alignment_exponent())?,
         })
     }
 }
diff --git a/vortex-file/src/footer/serializer.rs b/vortex-file/src/footer/serializer.rs
index 65a1c3c61c6..9d8aa245b86 100644
--- a/vortex-file/src/footer/serializer.rs
+++ b/vortex-file/src/footer/serializer.rs
@@ -13,12 +13,15 @@ use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::WriteFlatBufferExt;
 use vortex_layout::LayoutContext;
 use vortex_session::registry::ReadContext;
+use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::EOF_SIZE;
 use crate::Footer;
 use crate::MAGIC_BYTES;
 use crate::MAX_POSTSCRIPT_SIZE;
 use crate::VERSION;
+use crate::footer::FileMetadata;
+use crate::footer::SegmentSpec;
 use crate::footer::file_layout::FooterFlatBufferWriter;
 use crate::footer::postscript::Postscript;
 use crate::footer::postscript::PostscriptSegment;
@@ -26,6 +29,7 @@ use crate::footer::postscript::PostscriptSegment;
 /// Serializes a [`Footer`] into footer buffers and the trailing postscript/EOF marker.
 pub struct FooterSerializer {
     footer: Footer,
+    metadata: HashMap<String, ByteBuffer>,
     exclude_dtype: bool,
     offset: u64,
 }
@@ -34,6 +38,7 @@ impl FooterSerializer {
     pub(super) fn new(footer: Footer) -> Self {
         Self {
             footer,
+            metadata: HashMap::default(),
             exclude_dtype: false,
             offset: 0,
         }
@@ -62,11 +67,43 @@ impl FooterSerializer {
         self
     }
 
+    pub(crate) fn with_metadata_segments(mut self, metadata: HashMap<String, ByteBuffer>) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
     /// Serialize the footer into a byte buffer that can later be deserialized as a [`Footer`].
     /// This can be helpful for storing some footer data out-of-band to accelerate opening a file.
-    pub fn serialize(mut self) -> VortexResult<Vec<ByteBuffer>> {
+    pub fn serialize(self) -> VortexResult<Vec<ByteBuffer>> {
+        self.serialize_with_metadata()
+            .map(|(buffers, _metadata_segment, _approx_byte_size)| buffers)
+    }
+
+    pub(crate) fn serialize_with_metadata(
+        mut self,
+    ) -> VortexResult<(Vec<ByteBuffer>, Option<SegmentSpec>, usize)> {
         let mut buffers = vec![];
 
+        // All metadata serializes into one segment above the schema. Re-serializing an open footer
+        // without new metadata keeps its existing locator.
+        let metadata_segment = if self.metadata.is_empty() {
+            self.footer.metadata_segment().map(PostscriptSegment::from)
+        } else {
+            let file_metadata = FileMetadata::new(std::mem::take(&mut self.metadata));
+            // Pad so the segment offset meets the flatbuffer alignment the reader validates.
+            let alignment = FlatBuffer::alignment();
+            let padding = self.offset.next_multiple_of(*alignment as u64) - self.offset;
+            if padding > 0 {
+                buffers.push(ByteBuffer::zeroed(padding as usize));
+                self.offset += padding;
+            }
+            let (buffer, segment) = write_flatbuffer(&mut self.offset, &file_metadata)?;
+            buffers.push(buffer);
+            Some(segment)
+        };
+        let metadata_locator = metadata_segment.as_ref().map(SegmentSpec::from);
+        let metadata_storage_bytes = buffers.iter().map(ByteBuffer::len).sum::<usize>();
+
         let dtype_segment = if self.exclude_dtype {
             None
         } else {
@@ -111,6 +148,7 @@ impl FooterSerializer {
             layout: layout_segment,
             statistics: statistics_segment,
             footer: footer_segment,
+            metadata: metadata_segment,
         };
         let postscript_buffer = postscript.write_flatbuffer_bytes()?;
         if postscript_buffer.len() > MAX_POSTSCRIPT_SIZE as usize {
@@ -132,7 +170,29 @@ impl FooterSerializer {
         eof[4..8].copy_from_slice(&MAGIC_BYTES);
         buffers.push(ByteBuffer::copy_from(eof));
 
-        Ok(buffers)
+        let approx_byte_size =
+            buffers.iter().map(ByteBuffer::len).sum::<usize>() - metadata_storage_bytes;
+        Ok((buffers, metadata_locator, approx_byte_size))
+    }
+}
+
+impl From<&PostscriptSegment> for SegmentSpec {
+    fn from(value: &PostscriptSegment) -> Self {
+        Self {
+            offset: value.offset,
+            length: value.length,
+            alignment: value.alignment,
+        }
+    }
+}
+
+impl From<&SegmentSpec> for PostscriptSegment {
+    fn from(value: &SegmentSpec) -> Self {
+        Self {
+            offset: value.offset,
+            length: value.length,
+            alignment: value.alignment,
+        }
     }
 }
 
diff --git a/vortex-file/src/lib.rs b/vortex-file/src/lib.rs
index e9c7741af93..2602662cabf 100644
--- a/vortex-file/src/lib.rs
+++ b/vortex-file/src/lib.rs
@@ -64,6 +64,9 @@
 //! │          Segments          │  serialized array chunks and per-column
 //! │     (data & statistics)    │  statistics, in writer-chosen order
 //! ├────────────────────────────┤
+//! │    User-metadata segment   │  optional; a single `FileMetadata` flatbuffer of keyed,
+//! │                            │  opaque values (may live anywhere in the file)
+//! ├────────────────────────────┤
 //! │      DType flatbuffer      │  optional; omitted via `exclude_dtype`
 //! ├────────────────────────────┤
 //! │      Layout flatbuffer     │  required; the root Layout tree
@@ -73,8 +76,8 @@
 //! │      Footer flatbuffer     │  required; dictionary-encoded segment map
 //! │                            │  and array/layout/compression/encryption specs
 //! ├────────────────────────────┤
-//! │         Postscript         │  offsets of the four footer segments above;
-//! │                            │  at most 65528 bytes
+//! │         Postscript         │  locators for the footer and the optional user-metadata
+//! │                            │  segment; at most 65528 bytes
 //! ├────────────────────────────┤
 //! │     8-byte End of File     │  u16 version, u16 postscript length,
 //! │                            │  4 magic bytes 'VTXF'
@@ -82,8 +85,11 @@
 //! ```
 //!
 //! The postscript records the offset, length, and alignment of the dtype, layout, statistics, and
-//! footer segments, so a single read of the file tail (defaulting to 64KiB) is enough to locate and
-//! parse the footer. The byte-level format is specified in full at
+//! footer segments, plus an optional locator for a single user-metadata segment, so one read of the
+//! file tail (defaulting to 64KiB) locates and parses the footer. Metadata values live in that
+//! segment, read only on [`VortexOpenOptions::include_metadata`] (a targeted read, served from the
+//! initial read when already covered).
+//! The byte-level format is specified in full at
 //! <https://docs.vortex.dev/specs/file-format.html>.
 //!
 //! A Parquet-style file is realized by nesting a chunked layout of struct layouts of chunked layouts
diff --git a/vortex-file/src/multi/mod.rs b/vortex-file/src/multi/mod.rs
index 587768f17d0..3a21a71c137 100644
--- a/vortex-file/src/multi/mod.rs
+++ b/vortex-file/src/multi/mod.rs
@@ -285,3 +285,200 @@ impl LayoutReaderFactory for VortexFileReaderFactory {
         Ok(Some(file.layout_reader()?))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fmt;
+
+    use rstest::rstest;
+    use vortex_array::IntoArray;
+    use vortex_array::array_session;
+    use vortex_buffer::ByteBuffer;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_buffer::buffer;
+    use vortex_io::VortexReadAt;
+    use vortex_io::filesystem::FileSystem;
+    use vortex_io::session::RuntimeSession;
+    use vortex_layout::session::LayoutSession;
+
+    use super::*;
+    use crate::WriteOptionsSessionExt;
+
+    struct MetadataFileSystem {
+        bytes: ByteBuffer,
+    }
+
+    impl fmt::Debug for MetadataFileSystem {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("MetadataFileSystem").finish()
+        }
+    }
+
+    #[async_trait]
+    impl FileSystem for MetadataFileSystem {
+        fn list(&self, _prefix: &str) -> stream::BoxStream<'_, VortexResult<FileListing>> {
+            stream::empty().boxed()
+        }
+
+        async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+            Ok((path == "metadata.vortex").then_some(FileListing {
+                path: path.to_string(),
+                size: Some(self.bytes.len() as u64),
+            }))
+        }
+
+        async fn open_read(&self, _path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
+            Ok(Arc::new(self.bytes.clone()))
+        }
+
+        async fn delete(&self, _path: &str) -> VortexResult<()> {
+            Ok(())
+        }
+    }
+
+    // A cached footer carries only the metadata locator, so metadata resolution is independent of
+    // whether the file was first opened with or without `include_metadata`.
+    #[rstest]
+    #[case(true)]
+    #[case(false)]
+    #[tokio::test]
+    async fn test_cached_footer_metadata_order_independent(
+        #[case] default_first: bool,
+    ) -> VortexResult<()> {
+        let session = array_session()
+            .with::<LayoutSession>()
+            .with::<RuntimeSession>()
+            .with::<MultiFileSession>();
+        crate::register_default_encodings(&session);
+
+        let expected = ByteBuffer::copy_from(b"cached metadata");
+        let mut output = ByteBufferMut::empty();
+        session
+            .write_options()
+            .with_metadata_segment("key", expected.clone())
+            .write(&mut output, buffer![1u32].into_array().to_array_stream())
+            .await?;
+        let fs: FileSystemRef = Arc::new(MetadataFileSystem {
+            bytes: ByteBuffer::from(output),
+        });
+        let listing = FileListing {
+            path: "metadata.vortex".to_string(),
+            size: None,
+        };
+        let default_options = |options: VortexOpenOptions| options;
+        let metadata_options = |options: VortexOpenOptions| options.include_metadata();
+
+        // Open the same file twice through the cache, requesting metadata in the order set by
+        // `default_first`. The include-open must resolve the value and the default-open must see
+        // none, whichever comes first (the cached footer holds only the locator).
+        let (included, default) = if default_first {
+            let default = open_file(&fs, &listing, &session, &default_options).await?;
+            let included = open_file(&fs, &listing, &session, &metadata_options).await?;
+            (included, default)
+        } else {
+            let included = open_file(&fs, &listing, &session, &metadata_options).await?;
+            let default = open_file(&fs, &listing, &session, &default_options).await?;
+            (included, default)
+        };
+        assert_eq!(
+            included.metadata_segment("key").map(ByteBuffer::as_slice),
+            Some(expected.as_slice())
+        );
+        assert!(default.metadata_segment("key").is_none());
+
+        Ok(())
+    }
+
+    struct TwoFileSystem {
+        a: ByteBuffer,
+        b: ByteBuffer,
+    }
+
+    impl fmt::Debug for TwoFileSystem {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("TwoFileSystem").finish()
+        }
+    }
+
+    #[async_trait]
+    impl FileSystem for TwoFileSystem {
+        fn list(&self, _prefix: &str) -> stream::BoxStream<'_, VortexResult<FileListing>> {
+            stream::empty().boxed()
+        }
+
+        async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+            let size = match path {
+                "a.vortex" => self.a.len(),
+                "b.vortex" => self.b.len(),
+                _ => return Ok(None),
+            };
+            Ok(Some(FileListing {
+                path: path.to_string(),
+                size: Some(size as u64),
+            }))
+        }
+
+        async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
+            let bytes = match path {
+                "b.vortex" => self.b.clone(),
+                _ => self.a.clone(),
+            };
+            Ok(Arc::new(bytes))
+        }
+
+        async fn delete(&self, _path: &str) -> VortexResult<()> {
+            Ok(())
+        }
+    }
+
+    // Distinct files carry distinct metadata; opening both through the multi-file
+    // cache must not let one file's metadata leak into another (URI isolation).
+    #[tokio::test]
+    async fn test_multi_file_metadata_isolated_per_uri() -> VortexResult<()> {
+        let session = array_session()
+            .with::<LayoutSession>()
+            .with::<RuntimeSession>()
+            .with::<MultiFileSession>();
+        crate::register_default_encodings(&session);
+
+        let mut out_a = ByteBufferMut::empty();
+        session
+            .write_options()
+            .with_metadata_segment("k", ByteBuffer::copy_from(b"file-a"))
+            .write(&mut out_a, buffer![1u32].into_array().to_array_stream())
+            .await?;
+        let mut out_b = ByteBufferMut::empty();
+        session
+            .write_options()
+            .with_metadata_segment("k", ByteBuffer::copy_from(b"file-b"))
+            .write(&mut out_b, buffer![2u32].into_array().to_array_stream())
+            .await?;
+
+        let fs: FileSystemRef = Arc::new(TwoFileSystem {
+            a: ByteBuffer::from(out_a),
+            b: ByteBuffer::from(out_b),
+        });
+        let include = |options: VortexOpenOptions| options.include_metadata();
+
+        let a_listing = FileListing {
+            path: "a.vortex".to_string(),
+            size: None,
+        };
+        let b_listing = FileListing {
+            path: "b.vortex".to_string(),
+            size: None,
+        };
+        let fa = open_file(&fs, &a_listing, &session, &include).await?;
+        let fb = open_file(&fs, &b_listing, &session, &include).await?;
+
+        assert_eq!(
+            fa.metadata_segment("k").map(ByteBuffer::as_slice),
+            Some(b"file-a".as_slice())
+        );
+        assert_eq!(
+            fb.metadata_segment("k").map(ByteBuffer::as_slice),
+            Some(b"file-b".as_slice())
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 1bd42c7be41..174820abb15 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -20,6 +20,7 @@ use vortex_layout::segments::NoOpSegmentCache;
 use vortex_layout::segments::SegmentCache;
 use vortex_layout::segments::SegmentCacheSourceAdapter;
 use vortex_layout::segments::SegmentId;
+use vortex_layout::segments::SegmentSource;
 use vortex_layout::segments::SharedSegmentSource;
 use vortex_layout::session::LayoutSessionExt;
 use vortex_metrics::DefaultMetricsRegistry;
@@ -32,6 +33,7 @@ use crate::DeserializeStep;
 use crate::EOF_SIZE;
 use crate::MAX_POSTSCRIPT_SIZE;
 use crate::VortexFile;
+use crate::footer::FileMetadata;
 use crate::footer::Footer;
 use crate::segments::BufferSegmentSource;
 use crate::segments::FileSegmentSource;
@@ -60,6 +62,8 @@ pub struct VortexOpenOptions {
     dtype: Option<DType>,
     /// An optional, externally provided, file layout.
     footer: Option<Footer>,
+    /// Whether to include user-defined metadata segments when opening the file.
+    include_metadata: bool,
     /// The segments read during the initial read.
     initial_read_segments: RwLock<HashMap<SegmentId, ByteBuffer>>,
     /// A metrics registry for the file.
@@ -83,6 +87,7 @@ pub trait OpenOptionsSessionExt:
             file_size: None,
             dtype: None,
             footer: None,
+            include_metadata: false,
             initial_read_segments: Default::default(),
             metrics_registry: None,
             labels: Vec::default(),
@@ -162,6 +167,25 @@ impl VortexOpenOptions {
         self
     }
 
+    /// Include user-defined metadata segments when opening the file.
+    ///
+    /// By default, opening a file reads only the metadata required to interpret the layout.
+    /// Enabling this option loads all metadata segments named by the postscript, which may require
+    /// additional reads before the footer is returned.
+    pub fn include_metadata(mut self) -> Self {
+        self.include_metadata = true;
+        self
+    }
+
+    /// Configure whether user-defined metadata segments are included when opening the file.
+    ///
+    /// Enabling this option loads all metadata segments named by the postscript, which may require
+    /// additional reads before the footer is returned.
+    pub fn with_include_metadata(mut self, include_metadata: bool) -> Self {
+        self.include_metadata = include_metadata;
+        self
+    }
+
     /// Configure a custom [`MetricsRegistry`] implementation.
     pub fn with_metrics_registry(mut self, metrics: Arc<dyn MetricsRegistry>) -> Self {
         self.metrics_registry = Some(metrics);
@@ -211,6 +235,7 @@ impl VortexOpenOptions {
         }
 
         let cache_layout_reader = self.cache_layout_reader;
+        let include_metadata = self.include_metadata;
         let mut opts = self.with_initial_read_size(0);
 
         let footer = match opts.footer.take() {
@@ -218,11 +243,16 @@ impl VortexOpenOptions {
             None => block_on(opts.read_footer(&buffer))?,
         };
 
-        let segment_source = Arc::new(BufferSegmentSource::new(
+        let segment_source: Arc<dyn SegmentSource> = Arc::new(BufferSegmentSource::new(
             buffer,
-            Arc::clone(footer.segment_map()),
+            footer.segment_specs_with_metadata(),
         ));
-        let file = VortexFile::new(footer, segment_source, opts.session);
+        let metadata = if include_metadata {
+            block_on(resolve_metadata(&footer, Arc::clone(&segment_source)))?
+        } else {
+            Arc::new(HashMap::new())
+        };
+        let file = VortexFile::new(footer, segment_source, opts.session).with_metadata(metadata);
         Ok(if cache_layout_reader {
             file.with_caching()
         } else {
@@ -263,19 +293,25 @@ impl VortexOpenOptions {
 
         // Create a segment source backed by the VortexRead implementation.
         let segment_source = Arc::new(SharedSegmentSource::new(FileSegmentSource::open(
-            Arc::clone(footer.segment_map()),
+            footer.segment_specs_with_metadata(),
             reader,
             self.session.handle(),
             metrics,
         )));
 
         // Wrap up the segment source to first resolve segments from the initial read cache.
-        let segment_source = Arc::new(SegmentCacheSourceAdapter::new(
+        let segment_source: Arc<dyn SegmentSource> = Arc::new(SegmentCacheSourceAdapter::new(
             segment_cache,
             segment_source,
         ));
 
-        let file = VortexFile::new(footer, segment_source, self.session.clone());
+        let metadata = if self.include_metadata {
+            resolve_metadata(&footer, Arc::clone(&segment_source)).await?
+        } else {
+            Arc::new(HashMap::new())
+        };
+        let file =
+            VortexFile::new(footer, segment_source, self.session.clone()).with_metadata(metadata);
         Ok(if self.cache_layout_reader {
             file.with_caching()
         } else {
@@ -338,26 +374,43 @@ impl VortexOpenOptions {
         initial_read: &ByteBuffer,
         footer: &Footer,
     ) {
-        let first_idx = footer
-            .segment_map()
-            .partition_point(|segment| segment.offset < initial_offset);
-
         let mut initial_read_segments = self.initial_read_segments.write();
 
-        for idx in first_idx..footer.segment_map().len() {
-            let segment = &footer.segment_map()[idx];
+        for (idx, segment) in footer.segment_specs_with_metadata().iter().enumerate() {
+            if segment.offset < initial_offset {
+                continue;
+            }
             let segment_id =
                 SegmentId::from(u32::try_from(idx).vortex_expect("Invalid segment ID"));
             let offset =
                 usize::try_from(segment.offset - initial_offset).vortex_expect("Invalid offset");
-            let buffer = initial_read
-                .slice(offset..offset + (segment.length as usize))
-                .aligned(segment.alignment);
+            let end = offset + segment.length as usize;
+            if end > initial_read.len() {
+                continue;
+            }
+            let buffer = initial_read.slice(offset..end).aligned(segment.alignment);
             initial_read_segments.insert(segment_id, buffer);
         }
     }
 }
 
+async fn resolve_metadata(
+    footer: &Footer,
+    segment_source: Arc<dyn SegmentSource>,
+) -> VortexResult<Arc<HashMap<String, ByteBuffer>>> {
+    if footer.metadata_segment().is_none() {
+        return Ok(Arc::new(HashMap::new()));
+    }
+
+    // The metadata segment is appended to the segment map, so its id is the map length.
+    let id = SegmentId::from(u32::try_from(footer.segment_map().len())?);
+    let handle = segment_source.request(id).await?;
+    let buffer = handle.try_into_host()?.await?;
+    let metadata = FileMetadata::parse(buffer.as_slice())?;
+
+    Ok(Arc::new(metadata))
+}
+
 #[cfg(feature = "object_store")]
 impl VortexOpenOptions {
     /// Open a Vortex file from an `object_store` backend and path.
@@ -386,6 +439,7 @@ mod tests {
     use std::sync::atomic::Ordering;
 
     use futures::future::BoxFuture;
+    use parking_lot::Mutex;
     use vortex_array::IntoArray;
     use vortex_array::buffer::BufferHandle;
     use vortex_array::memory::DefaultHostAllocator;
@@ -408,6 +462,7 @@ mod tests {
         inner: R,
         total_read: Arc<AtomicUsize>,
         first_read_len: Arc<AtomicUsize>,
+        reads: Arc<Mutex<Vec<(u64, usize)>>>,
     }
 
     impl<R: VortexReadAt + Clone> VortexReadAt for CountingRead<R> {
@@ -422,6 +477,7 @@ mod tests {
             alignment: Alignment,
         ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
             self.total_read.fetch_add(length, Ordering::Relaxed);
+            self.reads.lock().push((offset, length));
             let _ = self.first_read_len.compare_exchange(
                 0,
                 length,
@@ -492,6 +548,7 @@ mod tests {
             inner: buffer,
             total_read: Arc::clone(&total_read),
             first_read_len: Arc::clone(&first_read_len),
+            reads: Arc::new(Mutex::new(Vec::new())),
         };
 
         // Open the file
@@ -508,6 +565,118 @@ mod tests {
         assert!(read < 1024 * 1024, "Read {} bytes, expected < 1MB", read);
     }
 
+    #[tokio::test]
+    async fn test_metadata_outside_initial_read_uses_targeted_read() -> VortexResult<()> {
+        let session = vortex_array::array_session()
+            .with::<LayoutSession>()
+            .with::<RuntimeSession>();
+        crate::register_default_encodings(&session);
+
+        let metadata = ByteBuffer::copy_from(vec![0x5a; INITIAL_READ_SIZE * 2]);
+        let mut output = ByteBufferMut::empty();
+        let summary = session
+            .write_options()
+            .with_metadata_segment("outside", metadata.clone())
+            .write(
+                &mut output,
+                Buffer::from(vec![1u32]).into_array().to_array_stream(),
+            )
+            .await?;
+        let locator = *summary
+            .footer()
+            .metadata_segment()
+            .vortex_expect("metadata locator");
+        let bytes = ByteBuffer::from(output);
+        assert!(locator.offset < bytes.len() as u64 - INITIAL_READ_SIZE as u64);
+
+        let default_total = Arc::new(AtomicUsize::new(0));
+        let default_reads = Arc::new(Mutex::new(Vec::new()));
+        let default_reader = CountingRead {
+            inner: bytes.clone(),
+            total_read: Arc::clone(&default_total),
+            first_read_len: Arc::new(AtomicUsize::new(0)),
+            reads: Arc::clone(&default_reads),
+        };
+        let default_file = session.open_options().open_read(default_reader).await?;
+        assert!(default_file.metadata_segment("outside").is_none());
+        assert!(
+            !default_reads
+                .lock()
+                .contains(&(locator.offset, locator.length as usize))
+        );
+        // A default open must not amplify into the metadata: total bytes read stay
+        // below the metadata segment's size (itself 2x the initial read).
+        assert!(
+            default_total.load(Ordering::Relaxed) < metadata.len(),
+            "default open read {} bytes; metadata segment is {}",
+            default_total.load(Ordering::Relaxed),
+            metadata.len()
+        );
+
+        let metadata_reads = Arc::new(Mutex::new(Vec::new()));
+        let metadata_reader = CountingRead {
+            inner: bytes,
+            total_read: Arc::new(AtomicUsize::new(0)),
+            first_read_len: Arc::new(AtomicUsize::new(0)),
+            reads: Arc::clone(&metadata_reads),
+        };
+        let file = session
+            .open_options()
+            .include_metadata()
+            .open_read(metadata_reader)
+            .await?;
+        assert_eq!(
+            file.metadata_segment("outside").map(ByteBuffer::as_slice),
+            Some(metadata.as_slice())
+        );
+        assert!(
+            metadata_reads
+                .lock()
+                .contains(&(locator.offset, locator.length as usize))
+        );
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_with_footer_include_metadata_open_buffer_resolves() -> VortexResult<()> {
+        let session = vortex_array::array_session()
+            .with::<LayoutSession>()
+            .with::<RuntimeSession>();
+        crate::register_default_encodings(&session);
+
+        let value = ByteBuffer::copy_from(b"supplied-footer metadata");
+        let mut output = ByteBufferMut::empty();
+        let summary = session
+            .write_options()
+            .with_metadata_segment("key", value.clone())
+            .write(
+                &mut output,
+                Buffer::from(vec![1u32]).into_array().to_array_stream(),
+            )
+            .await?;
+        let footer = summary.footer().clone();
+        let bytes = ByteBuffer::from(output);
+
+        let file = session
+            .open_options()
+            .with_footer(footer.clone())
+            .include_metadata()
+            .open_buffer(bytes.clone())?;
+        assert_eq!(
+            file.metadata_segment("key").map(ByteBuffer::as_slice),
+            Some(value.as_slice())
+        );
+
+        let default = session
+            .open_options()
+            .with_footer(footer)
+            .open_buffer(bytes)?;
+        assert!(default.metadata_segment("key").is_none());
+
+        Ok(())
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     #[tokio::test]
     async fn test_open_path_uses_memory_session_allocator() {
diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs
index ea7f8cbeda5..0d6c31a1eda 100644
--- a/vortex-file/src/tests.rs
+++ b/vortex-file/src/tests.rs
@@ -7,6 +7,7 @@ use std::sync::Arc;
 use std::sync::LazyLock;
 
 use bytes::Bytes;
+use flatbuffers::FlatBufferBuilder;
 use futures::StreamExt;
 use futures::TryStreamExt;
 use futures::pin_mut;
@@ -62,9 +63,12 @@ use vortex_btrblocks::BtrBlocksCompressorBuilder;
 use vortex_btrblocks::SchemeExt;
 use vortex_btrblocks::schemes::string::StringDictScheme;
 use vortex_buffer::Buffer;
+use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_buffer::buffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_flatbuffers::footer as fb;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::Layout;
 use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
@@ -75,6 +79,7 @@ use vortex_layout::scan::split_by::SplitBy;
 use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
 
+use crate::MAX_POSTSCRIPT_SIZE;
 use crate::OpenOptionsSessionExt;
 use crate::V1_FOOTER_FBS_SIZE;
 use crate::VERSION;
@@ -1691,6 +1696,172 @@ async fn test_writer_with_statistics() -> VortexResult<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_file_metadata_roundtrip() -> VortexResult<()> {
+    let array =
+        StructArray::from_fields(&[("numbers", buffer![1u32, 2, 3].into_array())])?.into_array();
+    let small = ByteBuffer::copy_from(b"{\"source\":\"test\"}");
+    // Larger than the postscript to prove metadata is not bounded by it.
+    let large = ByteBuffer::copy_from(vec![7u8; usize::from(MAX_POSTSCRIPT_SIZE) + 1024]);
+
+    let mut buf = ByteBufferMut::empty();
+    let summary = SESSION
+        .write_options()
+        .with_metadata_segment("json", ByteBuffer::copy_from(b"old"))
+        .with_metadata_segment("json", small.clone()) // last write wins
+        .with_metadata_segment("large", large.clone())
+        .with_metadata_segment("empty", ByteBuffer::empty())
+        .write(&mut buf, array.to_array_stream())
+        .await?;
+
+    // All metadata lives in a single segment, referenced by one postscript locator.
+    let locator = *summary
+        .footer()
+        .metadata_segment()
+        .vortex_expect("metadata locator");
+    assert!(locator.alignment.is_offset_aligned(locator.offset as usize));
+    // The footer holds only the locator, so its size does not grow with the large value.
+    assert!(summary.footer().approx_byte_size().unwrap() < large.len());
+
+    let bytes = ByteBuffer::from(buf);
+
+    let default = SESSION.open_options().open_buffer(bytes.clone())?;
+    assert_eq!(default.row_count(), 3);
+    assert_eq!(default.metadata_segments().count(), 0);
+    assert!(default.metadata_segment("json").is_none());
+
+    let file = SESSION
+        .open_options()
+        .include_metadata()
+        .open_buffer(bytes.clone())?;
+    assert_eq!(file.metadata_segments().count(), 3);
+    assert_eq!(
+        file.metadata_segment("json").map(ByteBuffer::as_slice),
+        Some(small.as_slice()) // last write wins
+    );
+    assert_eq!(
+        file.metadata_segment("large").map(ByteBuffer::as_slice),
+        Some(large.as_slice())
+    );
+    assert!(
+        file.metadata_segment("empty")
+            .vortex_expect("empty")
+            .is_empty()
+    );
+    assert!(file.metadata_segment("missing").is_none());
+
+    // Resolved values are copied out, not sliced from the file buffer.
+    let file_range = {
+        let s = bytes.as_ptr() as usize;
+        s..s + bytes.len()
+    };
+    let resolved = file.metadata_segment("json").vortex_expect("json");
+    assert!(!file_range.contains(&(resolved.as_ptr() as usize)));
+
+    Ok(())
+}
+
+/// A transform over a metadata locator's `(offset, length, alignment_exponent)`.
+type LocatorMutation = fn((u64, u32, u8)) -> (u64, u32, u8);
+
+/// Rewrite the postscript with its metadata locator `(offset, length, alignment_exponent)`
+/// transformed by `mutate`, producing a file with a corrupt metadata locator.
+fn corrupt_metadata_locator(bytes: &ByteBuffer, mutate: LocatorMutation) -> ByteBuffer {
+    let eof_offset = bytes.len() - crate::EOF_SIZE;
+    let postscript_len =
+        u16::from_le_bytes(bytes[eof_offset + 2..eof_offset + 4].try_into().unwrap()) as usize;
+    let postscript_offset = eof_offset - postscript_len;
+    let old = flatbuffers::root::<fb::Postscript>(&bytes[postscript_offset..eof_offset]).unwrap();
+
+    let copy_segment = |segment: fb::PostscriptSegment<'_>| {
+        (
+            segment.offset(),
+            segment.length(),
+            segment.alignment_exponent(),
+        )
+    };
+    let dtype = old.dtype().map(copy_segment);
+    let layout = copy_segment(old.layout().unwrap());
+    let statistics = old.statistics().map(copy_segment);
+    let footer = copy_segment(old.footer().unwrap());
+    let metadata = mutate(copy_segment(old.metadata().unwrap()));
+
+    fn create_segment<'a>(
+        fbb: &mut FlatBufferBuilder<'a>,
+        (offset, length, alignment_exponent): (u64, u32, u8),
+    ) -> flatbuffers::WIPOffset<fb::PostscriptSegment<'a>> {
+        fb::PostscriptSegment::create(
+            fbb,
+            &fb::PostscriptSegmentArgs {
+                offset,
+                length,
+                alignment_exponent,
+                _compression: None,
+                _encryption: None,
+            },
+        )
+    }
+
+    let mut fbb = FlatBufferBuilder::new();
+    let dtype = dtype.map(|segment| create_segment(&mut fbb, segment));
+    let layout = create_segment(&mut fbb, layout);
+    let statistics = statistics.map(|segment| create_segment(&mut fbb, segment));
+    let footer = create_segment(&mut fbb, footer);
+    let metadata = create_segment(&mut fbb, metadata);
+    let postscript = fb::Postscript::create(
+        &mut fbb,
+        &fb::PostscriptArgs {
+            dtype,
+            layout: Some(layout),
+            statistics,
+            footer: Some(footer),
+            metadata: Some(metadata),
+        },
+    );
+    fbb.finish_minimal(postscript);
+    let postscript = fbb.finished_data();
+
+    let mut corrupted =
+        ByteBufferMut::with_capacity(postscript_offset + postscript.len() + crate::EOF_SIZE);
+    corrupted.extend_from_slice(&bytes[..postscript_offset]);
+    corrupted.extend_from_slice(postscript);
+    corrupted.extend_from_slice(&VERSION.to_le_bytes());
+    corrupted.extend_from_slice(&(postscript.len() as u16).to_le_bytes());
+    corrupted.extend_from_slice(&crate::MAGIC_BYTES);
+    corrupted.freeze()
+}
+
+#[rstest]
+#[case::invalid_exponent(|(o, l, _)| (o, l, 64), "Alignment exponent")]
+#[case::misaligned_offset(|(o, l, _)| (o, l, 12), "is not aligned to")]
+#[case::out_of_range(|(o, _, e)| (o, u32::MAX, e), "exceeds file size")]
+#[tokio::test]
+async fn test_file_metadata_corrupt_locator_rejected(
+    #[case] mutate: LocatorMutation,
+    #[case] expected: &str,
+) -> VortexResult<()> {
+    let mut output = ByteBufferMut::empty();
+    SESSION
+        .write_options()
+        .with_metadata_segment("key", ByteBuffer::copy_from(b"value"))
+        .write(&mut output, buffer![1u32].into_array().to_array_stream())
+        .await?;
+    let corrupted = corrupt_metadata_locator(&ByteBuffer::from(output), mutate);
+
+    // A corrupt locator must be rejected on open whether or not metadata was requested.
+    for include_metadata in [false, true] {
+        let error = SESSION
+            .open_options()
+            .with_include_metadata(include_metadata)
+            .open_buffer(corrupted.clone())
+            .err()
+            .vortex_expect("corrupt metadata locator must fail open");
+        assert!(error.to_string().contains(expected), "got: {error}");
+    }
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn timestamp_unit_mismatch() -> Result<(), Box<dyn std::error::Error>> {
     // Write file with MILLISECONDS timestamps
diff --git a/vortex-file/src/writer.rs b/vortex-file/src/writer.rs
index 2afd61f7b23..125ab950100 100644
--- a/vortex-file/src/writer.rs
+++ b/vortex-file/src/writer.rs
@@ -47,6 +47,7 @@ use vortex_layout::sequence::SequentialStreamExt;
 use vortex_session::SessionExt;
 use vortex_session::VortexSession;
 use vortex_session::registry::ReadContext;
+use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::ALLOWED_ENCODINGS;
 use crate::Footer;
@@ -70,6 +71,7 @@ pub struct VortexWriteOptions {
     exclude_dtype: bool,
     max_variable_length_statistics_size: usize,
     file_statistics: Vec<Stat>,
+    metadata: HashMap<String, ByteBuffer>,
 }
 
 /// Extension trait for constructing [`VortexWriteOptions`] from a session.
@@ -83,6 +85,7 @@ pub trait WriteOptionsSessionExt: SessionExt {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 }
@@ -97,6 +100,7 @@ impl VortexWriteOptions {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 
@@ -125,6 +129,35 @@ impl VortexWriteOptions {
         self.file_statistics = file_statistics;
         self
     }
+
+    /// Add a user-defined metadata entry (keyed, opaque bytes); a repeated key replaces the
+    /// previous value. All entries are serialized into a single metadata segment; keys must be
+    /// non-empty.
+    pub fn with_metadata_segment(
+        mut self,
+        key: impl Into<String>,
+        metadata: impl Into<ByteBuffer>,
+    ) -> Self {
+        let key = key.into();
+        let metadata = metadata.into();
+        self.metadata.insert(key, metadata);
+        self
+    }
+
+    /// Add user-defined metadata segments to the file.
+    ///
+    /// If a key already exists, the previous segment for that key is replaced.
+    pub fn with_metadata_segments<I, K, B>(mut self, metadata: I) -> Self
+    where
+        I: IntoIterator<Item = (K, B)>,
+        K: Into<String>,
+        B: Into<ByteBuffer>,
+    {
+        for (key, metadata) in metadata {
+            self = self.with_metadata_segment(key, metadata);
+        }
+        self
+    }
 }
 
 impl VortexWriteOptions {
@@ -157,6 +190,8 @@ impl VortexWriteOptions {
         mut write: W,
         stream: SendableArrayStream,
     ) -> VortexResult<WriteSummary> {
+        validate_metadata_segments(&self.metadata)?;
+
         // NOTE(os): Setup an array context that already has all known encodings pre-populated.
         // This is preferred for now over having an empty context here, because only the
         // serialised array order is deterministic. The serialisation of arrays are done
@@ -225,31 +260,32 @@ impl VortexWriteOptions {
         let (layout, segment_specs) = layout_fut.await?;
 
         // Assemble the Footer object now that we have all the segments.
+        let statistics = if self.file_statistics.is_empty() {
+            None
+        } else {
+            Some(FileStatistics::new_with_dtype(
+                file_stats.stats_sets().into(),
+                &dtype,
+            ))
+        };
         let mut footer = Footer::new(
             Arc::clone(&layout),
             segment_specs,
-            if self.file_statistics.is_empty() {
-                None
-            } else {
-                Some(FileStatistics::new_with_dtype(
-                    file_stats.stats_sets().into(),
-                    &dtype,
-                ))
-            },
+            statistics,
             ReadContext::new(ctx.to_ids()),
         );
 
         // Emit the footer buffers and EOF.
-        let footer_buffers = footer
+        let (footer_buffers, metadata_locator, approx_byte_size) = footer
             .clone()
             .into_serializer()
+            .with_metadata_segments(self.metadata)
             .with_offset(position)
             .with_exclude_dtype(self.exclude_dtype)
-            .serialize()?;
-
-        // Update the approx footer size in the footer object, so it can be used for caching and
-        // memory management in the future.
-        footer = footer.with_approx_byte_size(footer_buffers.iter().map(|b| b.len()).sum());
+            .serialize_with_metadata()?;
+        footer = footer
+            .with_metadata_segment(metadata_locator)
+            .with_approx_byte_size(approx_byte_size);
 
         for buffer in footer_buffers {
             position += buffer.len() as u64;
@@ -289,6 +325,16 @@ impl VortexWriteOptions {
     }
 }
 
+fn validate_metadata_segments(metadata: &HashMap<String, ByteBuffer>) -> VortexResult<()> {
+    for key in metadata.keys() {
+        if key.is_empty() {
+            vortex_bail!("Vortex metadata keys must be non-empty");
+        }
+    }
+
+    Ok(())
+}
+
 /// An async API for writing Vortex files.
 pub struct Writer<'w> {
     // The input channel for sending arrays to the writer.
diff --git a/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs b/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
index 9d6e4be1d1c..55f6d17b830 100644
--- a/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
+++ b/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
@@ -20,6 +20,8 @@ include "vortex-layout/layout.fbs";
 ///
 /// The segments pointed to by the postscript have inline compression and encryption specs to avoid
 /// the need to fetch encryption schemes up-front.
+///
+/// New fields must be appended to preserve FlatBuffers field-order compatibility with old readers.
 table Postscript {
     /// Segment containing the root `DType` flatbuffer.
     dtype: PostscriptSegment;
@@ -29,6 +31,9 @@ table Postscript {
     statistics: PostscriptSegment;
     /// Segment containing the 'Footer' flatbuffer (required)
     footer: PostscriptSegment;
+    /// Segment containing user-defined file-level metadata (a `FileMetadata` flatbuffer). The
+    /// segment may live anywhere in the file; readers load it only on demand.
+    metadata: PostscriptSegment;
 }
 
 /// A `PostscriptSegment` describes the location of a segment in the file without referencing any
@@ -43,6 +48,20 @@ table PostscriptSegment {
 // [postscript]
 
 // [footer]
+/// User-defined file-level metadata: opaque byte values keyed by unique, non-empty strings.
+///
+/// A future revision may add an optional child-segment locator to `MetadataEntry` to support a
+/// tree of metadata segments; the current format stores every value inline in a single segment.
+table FileMetadata {
+    entries: [MetadataEntry];
+}
+
+/// A single user-defined metadata entry: an opaque byte value keyed by a string.
+table MetadataEntry {
+    key: string (required);
+    value: [ubyte] (required);
+}
+
 /// The `FileStatistics` object contains file-level statistics for the Vortex file.
 table FileStatistics {
     /// Statistics for each field in the root schema. If the root schema is not a struct, there will
@@ -113,5 +132,6 @@ table EncryptionSpec {
 // [footer]
 
 root_type FileStatistics;
+root_type FileMetadata;
 root_type Footer;
 root_type Postscript;
diff --git a/vortex-flatbuffers/src/generated/footer.rs b/vortex-flatbuffers/src/generated/footer.rs
index 842a151edc7..aa0c44ebc6c 100644
--- a/vortex-flatbuffers/src/generated/footer.rs
+++ b/vortex-flatbuffers/src/generated/footer.rs
@@ -342,6 +342,8 @@ pub enum PostscriptOffset {}
 ///
 /// The segments pointed to by the postscript have inline compression and encryption specs to avoid
 /// the need to fetch encryption schemes up-front.
+///
+/// New fields must be appended to preserve FlatBuffers field-order compatibility with old readers.
 pub struct Postscript<'a> {
   pub _tab: ::flatbuffers::Table<'a>,
 }
@@ -359,6 +361,7 @@ impl<'a> Postscript<'a> {
   pub const VT_LAYOUT: ::flatbuffers::VOffsetT = 6;
   pub const VT_STATISTICS: ::flatbuffers::VOffsetT = 8;
   pub const VT_FOOTER: ::flatbuffers::VOffsetT = 10;
+  pub const VT_METADATA: ::flatbuffers::VOffsetT = 12;
 
   #[inline]
   pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
@@ -370,6 +373,7 @@ impl<'a> Postscript<'a> {
     args: &'args PostscriptArgs<'args>
   ) -> ::flatbuffers::WIPOffset<Postscript<'bldr>> {
     let mut builder = PostscriptBuilder::new(_fbb);
+    if let Some(x) = args.metadata { builder.add_metadata(x); }
     if let Some(x) = args.footer { builder.add_footer(x); }
     if let Some(x) = args.statistics { builder.add_statistics(x); }
     if let Some(x) = args.layout { builder.add_layout(x); }
@@ -410,6 +414,15 @@ impl<'a> Postscript<'a> {
     // which contains a valid value in this slot
     unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_FOOTER, None)}
   }
+  /// Segment containing user-defined file-level metadata (a `FileMetadata` flatbuffer). The
+  /// segment may live anywhere in the file; readers load it only on demand.
+  #[inline]
+  pub fn metadata(&self) -> Option<PostscriptSegment<'a>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_METADATA, None)}
+  }
 }
 
 impl ::flatbuffers::Verifiable for Postscript<'_> {
@@ -422,6 +435,7 @@ impl ::flatbuffers::Verifiable for Postscript<'_> {
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("layout", Self::VT_LAYOUT, false)?
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("statistics", Self::VT_STATISTICS, false)?
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("footer", Self::VT_FOOTER, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("metadata", Self::VT_METADATA, false)?
      .finish();
     Ok(())
   }
@@ -431,6 +445,7 @@ pub struct PostscriptArgs<'a> {
     pub layout: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
     pub statistics: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
     pub footer: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
+    pub metadata: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
 }
 impl<'a> Default for PostscriptArgs<'a> {
   #[inline]
@@ -440,6 +455,7 @@ impl<'a> Default for PostscriptArgs<'a> {
       layout: None,
       statistics: None,
       footer: None,
+      metadata: None,
     }
   }
 }
@@ -466,6 +482,10 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptBuilder<'a, 'b, A>
     self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_FOOTER, footer);
   }
   #[inline]
+  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_METADATA, metadata);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptBuilder<'a, 'b, A> {
     let start = _fbb.start_table();
     PostscriptBuilder {
@@ -487,6 +507,7 @@ impl ::core::fmt::Debug for Postscript<'_> {
       ds.field("layout", &self.layout());
       ds.field("statistics", &self.statistics());
       ds.field("footer", &self.footer());
+      ds.field("metadata", &self.metadata());
       ds.finish()
   }
 }
@@ -656,6 +677,222 @@ impl ::core::fmt::Debug for PostscriptSegment<'_> {
       ds.finish()
   }
 }
+pub enum FileMetadataOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// User-defined file-level metadata: opaque byte values keyed by unique, non-empty strings.
+///
+/// A future revision may add an optional child-segment locator to `MetadataEntry` to support a
+/// tree of metadata segments; the current format stores every value inline in a single segment.
+pub struct FileMetadata<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for FileMetadata<'a> {
+  type Inner = FileMetadata<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> FileMetadata<'a> {
+  pub const VT_ENTRIES: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    FileMetadata { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args FileMetadataArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<FileMetadata<'bldr>> {
+    let mut builder = FileMetadataBuilder::new(_fbb);
+    if let Some(x) = args.entries { builder.add_entries(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn entries(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataEntry<'a>>>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataEntry>>>>(FileMetadata::VT_ENTRIES, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for FileMetadata<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MetadataEntry>>>>("entries", Self::VT_ENTRIES, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct FileMetadataArgs<'a> {
+    pub entries: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataEntry<'a>>>>>,
+}
+impl<'a> Default for FileMetadataArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    FileMetadataArgs {
+      entries: None,
+    }
+  }
+}
+
+pub struct FileMetadataBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FileMetadataBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_entries(&mut self, entries: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<MetadataEntry<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(FileMetadata::VT_ENTRIES, entries);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> FileMetadataBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    FileMetadataBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<FileMetadata<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for FileMetadata<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("FileMetadata");
+      ds.field("entries", &self.entries());
+      ds.finish()
+  }
+}
+pub enum MetadataEntryOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// A single user-defined metadata entry: an opaque byte value keyed by a string.
+pub struct MetadataEntry<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for MetadataEntry<'a> {
+  type Inner = MetadataEntry<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> MetadataEntry<'a> {
+  pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+  pub const VT_VALUE: ::flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    MetadataEntry { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args MetadataEntryArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<MetadataEntry<'bldr>> {
+    let mut builder = MetadataEntryBuilder::new(_fbb);
+    if let Some(x) = args.value { builder.add_value(x); }
+    if let Some(x) = args.key { builder.add_key(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn key(&self) -> &'a str {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MetadataEntry::VT_KEY, None).unwrap()}
+  }
+  #[inline]
+  pub fn value(&self) -> ::flatbuffers::Vector<'a, u8> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(MetadataEntry::VT_VALUE, None).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for MetadataEntry<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, true)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("value", Self::VT_VALUE, true)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct MetadataEntryArgs<'a> {
+    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub value: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+}
+impl<'a> Default for MetadataEntryArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    MetadataEntryArgs {
+      key: None, // required field
+      value: None, // required field
+    }
+  }
+}
+
+pub struct MetadataEntryBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MetadataEntryBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MetadataEntry::VT_KEY, key);
+  }
+  #[inline]
+  pub fn add_value(&mut self, value: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MetadataEntry::VT_VALUE, value);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MetadataEntryBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    MetadataEntryBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<MetadataEntry<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    self.fbb_.required(o, MetadataEntry::VT_KEY,"key");
+    self.fbb_.required(o, MetadataEntry::VT_VALUE,"value");
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for MetadataEntry<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("MetadataEntry");
+      ds.field("key", &self.key());
+      ds.field("value", &self.value());
+      ds.finish()
+  }
+}
 pub enum FileStatisticsOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
diff --git a/vortex-tui/src/inspect.rs b/vortex-tui/src/inspect.rs
index 5543716fb2b..b035036be99 100644
--- a/vortex-tui/src/inspect.rs
+++ b/vortex-tui/src/inspect.rs
@@ -402,34 +402,28 @@ impl<'a> VortexInspector<'a> {
         let fb_postscript = root::<fb::Postscript>(&postscript_buffer)
             .map_err(|e| vortex_err!("Failed to parse postscript flatbuffer: {}", e))?;
 
-        let dtype = fb_postscript.dtype().map(|s| SegmentInfo {
-            offset: s.offset(),
-            length: s.length(),
-            alignment: Alignment::from_exponent(s.alignment_exponent()),
-        });
-
-        let layout = fb_postscript
-            .layout()
-            .map(|s| SegmentInfo {
+        let segment_info = |s: fb::PostscriptSegment<'_>| -> VortexResult<SegmentInfo> {
+            Ok(SegmentInfo {
                 offset: s.offset(),
                 length: s.length(),
-                alignment: Alignment::from_exponent(s.alignment_exponent()),
+                alignment: Alignment::try_from_exponent(s.alignment_exponent())?,
             })
+        };
+
+        let dtype = fb_postscript.dtype().map(segment_info).transpose()?;
+
+        let layout = fb_postscript
+            .layout()
+            .map(segment_info)
+            .transpose()?
             .ok_or_else(|| vortex_err!("Postscript missing layout segment"))?;
 
-        let statistics = fb_postscript.statistics().map(|s| SegmentInfo {
-            offset: s.offset(),
-            length: s.length(),
-            alignment: Alignment::from_exponent(s.alignment_exponent()),
-        });
+        let statistics = fb_postscript.statistics().map(segment_info).transpose()?;
 
         let footer = fb_postscript
             .footer()
-            .map(|s| SegmentInfo {
-                offset: s.offset(),
-                length: s.length(),
-                alignment: Alignment::from_exponent(s.alignment_exponent()),
-            })
+            .map(segment_info)
+            .transpose()?
             .ok_or_else(|| vortex_err!("Postscript missing footer segment"))?;
 
         Ok(PostscriptInfo {