diff --git a/docs/specs/file-format.md b/docs/specs/file-format.md
index b9ce8da2eed..4a977365cb8 100644
--- a/docs/specs/file-format.md
+++ b/docs/specs/file-format.md
@@ -54,6 +54,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. up to 16 user-defined `metadata` segments, each identified by a unique, non-empty UTF-8 key of at most 64 bytes
+
+The postscript carries a locator (offset, length, and alignment) for each metadata segment that is
+present; a file written without user metadata (and any file predating this feature) carries none.
+Readers do not load the opaque metadata values by default. Opt-in metadata reads resolve each
+locator separately, allowing values outside the initial file-tail read to be fetched without reading
+the intervening file contents.
 
 :::{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 691d10eeb45..0e32c1f31b7 100644
--- a/vortex-buffer/src/alignment.rs
+++ b/vortex-buffer/src/alignment.rs
@@ -117,9 +117,14 @@ impl 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)
     }
 
diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs
index 2fc27039c06..739d7c9fd8b 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 9fb29db12fd..992070fb0a6 100644
--- a/vortex-file/src/footer/deserializer.rs
+++ b/vortex-file/src/footer/deserializer.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use flatbuffers::root;
 use vortex_array::dtype::DType;
 use vortex_buffer::ByteBuffer;
@@ -18,6 +20,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;
 
@@ -177,14 +180,50 @@ impl FooterDeserializer {
                 )
             })
             .transpose()?;
+        let metadata = postscript
+            .metadata
+            .iter()
+            .map(|metadata| {
+                let segment = SegmentSpec {
+                    offset: metadata.segment.offset,
+                    length: metadata.segment.length,
+                    alignment: metadata.segment.alignment,
+                };
+                let end = segment
+                    .offset
+                    .checked_add(u64::from(segment.length))
+                    .ok_or_else(|| {
+                        vortex_err!("Metadata segment {} range overflowed u64", metadata.key)
+                    })?;
+                if end > file_size {
+                    vortex_bail!(
+                        "Metadata segment {} range {}..{} exceeds file size {}",
+                        metadata.key,
+                        segment.offset,
+                        end,
+                        file_size
+                    );
+                }
+                let offset = usize::try_from(segment.offset)?;
+                if !segment.alignment.is_offset_aligned(offset) {
+                    vortex_bail!(
+                        "Metadata segment {} offset {} is not aligned to {}",
+                        metadata.key,
+                        segment.offset,
+                        segment.alignment
+                    );
+                }
+                Ok((metadata.key.clone(), segment))
+            })
+            .collect::<VortexResult<Arc<[_]>>>()?;
 
         Ok(DeserializeStep::Done(self.parse_footer(
             initial_offset,
             &self.buffer,
-            &postscript.footer,
-            &postscript.layout,
+            postscript,
             dtype,
             file_stats,
+            metadata,
         )?))
     }
 
@@ -269,19 +308,29 @@ impl FooterDeserializer {
         &self,
         initial_offset: u64,
         initial_read: &[u8],
-        footer_segment: &PostscriptSegment,
-        layout_segment: &PostscriptSegment,
+        postscript: &Postscript,
         dtype: DType,
         file_stats: Option<FileStatistics>,
+        metadata: Arc<[(String, SegmentSpec)]>,
     ) -> VortexResult<Footer> {
+        let footer_segment = &postscript.footer;
         let footer_bytes = checked_segment_slice(initial_read, initial_offset, footer_segment)?;
+
+        let layout_segment = &postscript.layout;
         let layout_bytes = FlatBuffer::copy_from(checked_segment_slice(
             initial_read,
             initial_offset,
             layout_segment,
         )?);
 
-        Footer::from_flatbuffer(footer_bytes, layout_bytes, dtype, file_stats, &self.session)
+        Footer::from_flatbuffer(
+            footer_bytes,
+            layout_bytes,
+            dtype,
+            file_stats,
+            metadata,
+            &self.session,
+        )
     }
 }
 
@@ -374,6 +423,7 @@ mod tests {
             layout: segment(0, 1),
             statistics: None,
             footer: footer_segment,
+            metadata: Vec::new(),
         };
         let buffer = eof_buffer(&postscript)?;
         let file_size = buffer.len() as u64;
@@ -393,6 +443,7 @@ mod tests {
             layout: segment(0, 1),
             statistics: None,
             footer: segment(1, 1),
+            metadata: Vec::new(),
         };
         let buffer = eof_buffer(&postscript)?;
         let declared_size = buffer.len() as u64 - 1;
diff --git a/vortex-file/src/footer/mod.rs b/vortex-file/src/footer/mod.rs
index 114b38750a2..0d1c46f860a 100644
--- a/vortex-file/src/footer/mod.rs
+++ b/vortex-file/src/footer/mod.rs
@@ -39,12 +39,27 @@ use vortex_layout::layout_from_flatbuffer_with_options;
 use vortex_session::VortexSession;
 use vortex_session::registry::ReadContext;
 
+/// Maximum number of user-defined metadata segments. Keeps postscript bookkeeping small so the
+/// footer and required segments still fit the initial tail read.
+pub(crate) const MAX_METADATA_SEGMENTS: usize = 16;
+
+/// Maximum length, in UTF-8 bytes, of a user-defined metadata key (keys live in the postscript).
+///
+/// 64 bytes covers reverse-DNS query-engine keys, not just short Iceberg-style keys: e.g.
+/// `org.apache.spark.sql.parquet.row.metadata` (41 bytes), which Spark writes into every Parquet
+/// file. With [`MAX_METADATA_SEGMENTS`] keys this bounds the postscript key budget at 1 KiB.
+pub(crate) const MAX_METADATA_KEY_BYTES: usize = 64;
+
+/// User-defined metadata segment locators stored as `(key, locator)` pairs.
+pub(crate) type MetadataSegments = Arc<[(String, SegmentSpec)]>;
+
 /// Captures the layout information of a Vortex file.
 #[derive(Debug, Clone)]
 pub struct Footer {
     root_layout: LayoutRef,
     segments: Arc<[SegmentSpec]>,
     statistics: Option<FileStatistics>,
+    metadata: Arc<[(String, 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.
@@ -62,6 +77,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
+            metadata: Arc::from([]),
             array_read_ctx,
             approx_byte_size: None,
         }
@@ -78,9 +94,14 @@ impl Footer {
         layout_bytes: FlatBuffer,
         dtype: DType,
         statistics: Option<FileStatistics>,
+        metadata: Arc<[(String, SegmentSpec)]>,
         session: &VortexSession,
     ) -> VortexResult<Self> {
-        let approx_byte_size = footer_bytes.len() + layout_bytes.len();
+        let metadata_bytes: usize = metadata
+            .iter()
+            .map(|(key, _segment)| key.len() + size_of::<SegmentSpec>())
+            .sum();
+        let approx_byte_size = footer_bytes.len() + layout_bytes.len() + metadata_bytes;
         let fb_footer = root::<fb::Footer>(footer_bytes)?;
 
         // Create a LayoutContext from the registry.
@@ -128,6 +149,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
+            metadata,
             array_read_ctx,
             approx_byte_size: Some(approx_byte_size),
         })
@@ -148,6 +170,33 @@ impl Footer {
         self.statistics.as_ref()
     }
 
+    /// Returns the user-defined metadata segment locators stored in the postscript.
+    pub fn metadata_segments(&self) -> impl Iterator<Item = (&str, &SegmentSpec)> {
+        self.metadata
+            .iter()
+            .map(|(key, segment)| (key.as_str(), segment))
+    }
+
+    /// Returns the user-defined metadata segment locator for the given key.
+    pub fn metadata_segment(&self, key: &str) -> Option<&SegmentSpec> {
+        self.metadata
+            .iter()
+            .find_map(|(candidate, segment)| (candidate == key).then_some(segment))
+    }
+
+    pub(crate) fn with_metadata_segments(mut self, metadata: Arc<[(String, SegmentSpec)]>) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
+    pub(crate) fn segment_specs_with_metadata(&self) -> Arc<[SegmentSpec]> {
+        self.segments
+            .iter()
+            .copied()
+            .chain(self.metadata.iter().map(|(_, segment)| *segment))
+            .collect()
+    }
+
     /// Computes the compressed size in bytes of every field in the file, keyed by field path.
     ///
     /// Sizes are derived by attributing each segment in the [segment map][Self::segment_map] to a
diff --git a/vortex-file/src/footer/postscript.rs b/vortex-file/src/footer/postscript.rs
index 6086c777b61..c26ac83a8d6 100644
--- a/vortex-file/src/footer/postscript.rs
+++ b/vortex-file/src/footer/postscript.rs
@@ -12,6 +12,10 @@ use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::ReadFlatBuffer;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::footer as fb;
+use vortex_utils::aliases::hash_set::HashSet;
+
+use super::MAX_METADATA_KEY_BYTES;
+use super::MAX_METADATA_SEGMENTS;
 
 /// The postscript captures the locations and compression for the initial segments required for
 /// reading a Vortex file.
@@ -20,6 +24,7 @@ pub(crate) struct Postscript {
     pub(crate) layout: PostscriptSegment,
     pub(crate) statistics: Option<PostscriptSegment>,
     pub(crate) footer: PostscriptSegment,
+    pub(crate) metadata: Vec<PostscriptMetadata>,
 }
 
 impl FlatBufferRoot for Postscript {}
@@ -31,6 +36,16 @@ impl WriteFlatBuffer for Postscript {
         &self,
         fbb: &mut FlatBufferBuilder<'fb>,
     ) -> VortexResult<WIPOffset<Self::Target<'fb>>> {
+        validate_metadata_entries(&self.metadata)?;
+        self.write_flatbuffer_unchecked(fbb)
+    }
+}
+
+impl Postscript {
+    fn write_flatbuffer_unchecked<'fb>(
+        &self,
+        fbb: &mut FlatBufferBuilder<'fb>,
+    ) -> VortexResult<WIPOffset<fb::Postscript<'fb>>> {
         let dtype = self
             .dtype
             .as_ref()
@@ -43,6 +58,15 @@ impl WriteFlatBuffer for Postscript {
             .map(|ps| ps.write_flatbuffer(fbb))
             .transpose()?;
         let footer = self.footer.write_flatbuffer(fbb)?;
+        let metadata = if self.metadata.is_empty() {
+            None
+        } else {
+            let mut metadata = Vec::with_capacity(self.metadata.len());
+            for entry in &self.metadata {
+                metadata.push(entry.write_flatbuffer(fbb)?);
+            }
+            Some(fbb.create_vector(metadata.as_slice()))
+        };
         Ok(fb::Postscript::create(
             fbb,
             &fb::PostscriptArgs {
@@ -50,6 +74,7 @@ impl WriteFlatBuffer for Postscript {
                 layout: Some(layout),
                 statistics,
                 footer: Some(footer),
+                metadata,
             },
         ))
     }
@@ -62,6 +87,28 @@ impl ReadFlatBuffer for Postscript {
     fn read_flatbuffer<'buf>(
         fb: &<Self::Source<'buf> as Follow<'buf>>::Inner,
     ) -> Result<Self, Self::Error> {
+        let metadata = match fb.metadata() {
+            Some(metadata) => {
+                let metadata_len = metadata.len();
+                if metadata_len > MAX_METADATA_SEGMENTS {
+                    return Err(metadata_count_error(metadata_len));
+                }
+
+                let mut seen_keys = HashSet::with_capacity(metadata_len);
+                let mut entries = Vec::with_capacity(metadata_len);
+                for entry in metadata.iter() {
+                    let entry = PostscriptMetadata::read_flatbuffer(&entry)?;
+                    validate_metadata_key(&entry.key)?;
+                    if !seen_keys.insert(entry.key.clone()) {
+                        return Err(duplicate_metadata_key_error(&entry.key));
+                    }
+                    entries.push(entry);
+                }
+                entries
+            }
+            None => Vec::new(),
+        };
+
         Ok(Self {
             dtype: fb
                 .dtype()
@@ -79,6 +126,103 @@ impl ReadFlatBuffer for Postscript {
                 &fb.footer()
                     .ok_or_else(|| vortex_err!("Postscript missing footer segment"))?,
             )?,
+            metadata,
+        })
+    }
+}
+
+fn validate_metadata_entries(metadata: &[PostscriptMetadata]) -> VortexResult<()> {
+    if metadata.len() > MAX_METADATA_SEGMENTS {
+        return Err(metadata_count_error(metadata.len()));
+    }
+
+    let mut seen_keys = HashSet::with_capacity(metadata.len());
+    for entry in metadata {
+        validate_metadata_key(&entry.key)?;
+        if !seen_keys.insert(&entry.key) {
+            return Err(duplicate_metadata_key_error(&entry.key));
+        }
+    }
+
+    Ok(())
+}
+
+fn metadata_count_error(metadata_len: usize) -> VortexError {
+    vortex_err!(
+        "Postscript contains {} metadata segments, but Vortex supports at most {} metadata segments; metadata keys must be non-empty and at most {} bytes",
+        metadata_len,
+        MAX_METADATA_SEGMENTS,
+        MAX_METADATA_KEY_BYTES
+    )
+}
+
+fn duplicate_metadata_key_error(key: &str) -> VortexError {
+    vortex_err!(
+        "Postscript contains duplicate metadata key {key}; metadata keys must be unique, non-empty, and at most {} bytes, and files may contain at most {} metadata segments",
+        MAX_METADATA_KEY_BYTES,
+        MAX_METADATA_SEGMENTS
+    )
+}
+
+fn validate_metadata_key(key: &str) -> VortexResult<()> {
+    if key.is_empty() {
+        return Err(vortex_err!(
+            "Postscript metadata key must not be empty; metadata keys must be at most {} bytes and files may contain at most {} metadata segments",
+            MAX_METADATA_KEY_BYTES,
+            MAX_METADATA_SEGMENTS
+        ));
+    }
+
+    let key_bytes = key.len();
+    if key_bytes > MAX_METADATA_KEY_BYTES {
+        return Err(vortex_err!(
+            "Postscript metadata key {key:?} is {key_bytes} bytes, but metadata keys must be at most {} bytes and files may contain at most {} metadata segments",
+            MAX_METADATA_KEY_BYTES,
+            MAX_METADATA_SEGMENTS
+        ));
+    }
+
+    Ok(())
+}
+
+pub(crate) struct PostscriptMetadata {
+    pub(crate) key: String,
+    pub(crate) segment: PostscriptSegment,
+}
+
+impl FlatBufferRoot for PostscriptMetadata {}
+
+impl WriteFlatBuffer for PostscriptMetadata {
+    type Target<'a> = fb::PostscriptMetadata<'a>;
+
+    fn write_flatbuffer<'fb>(
+        &self,
+        fbb: &mut FlatBufferBuilder<'fb>,
+    ) -> VortexResult<WIPOffset<Self::Target<'fb>>> {
+        let key = fbb.create_string(&self.key);
+        let segment = self.segment.write_flatbuffer(fbb)?;
+        Ok(fb::PostscriptMetadata::create(
+            fbb,
+            &fb::PostscriptMetadataArgs {
+                key: Some(key),
+                segment: Some(segment),
+            },
+        ))
+    }
+}
+
+impl ReadFlatBuffer for PostscriptMetadata {
+    type Source<'a> = fb::PostscriptMetadata<'a>;
+    type Error = VortexError;
+
+    fn read_flatbuffer<'buf>(
+        fb: &<Self::Source<'buf> as Follow<'buf>>::Inner,
+    ) -> Result<Self, Self::Error> {
+        // The FlatBuffers verifier enforces that `key` and `segment` are present before this
+        // accessor can panic on a malformed required field.
+        Ok(Self {
+            key: fb.key().to_string(),
+            segment: PostscriptSegment::read_flatbuffer(&fb.segment())?,
         })
     }
 }
@@ -127,3 +271,184 @@ impl ReadFlatBuffer for PostscriptSegment {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::ByteBuffer;
+    use vortex_flatbuffers::FlatBuffer;
+    use vortex_flatbuffers::ReadFlatBuffer;
+    use vortex_flatbuffers::WriteFlatBufferExt;
+
+    use super::*;
+    use crate::MAX_POSTSCRIPT_SIZE;
+
+    fn segment(offset: u64) -> PostscriptSegment {
+        PostscriptSegment {
+            offset,
+            length: 1,
+            alignment: Alignment::none(),
+        }
+    }
+
+    fn write_postscript_bytes_unchecked(postscript: &Postscript) -> FlatBuffer {
+        let mut fbb = FlatBufferBuilder::new();
+        let root_offset = postscript.write_flatbuffer_unchecked(&mut fbb).unwrap();
+        fbb.finish_minimal(root_offset);
+        let (vec, start) = fbb.collapse();
+        let end = vec.len();
+        FlatBuffer::align_from(ByteBuffer::from(vec).slice(start..end))
+    }
+
+    fn read_postscript_error(postscript: &Postscript) -> String {
+        let bytes = write_postscript_bytes_unchecked(postscript);
+        match Postscript::read_flatbuffer_bytes(&bytes) {
+            Ok(_) => panic!("expected postscript read to fail"),
+            Err(err) => err.to_string(),
+        }
+    }
+
+    fn write_postscript_error(postscript: &Postscript) -> String {
+        match postscript.write_flatbuffer_bytes() {
+            Ok(_) => panic!("expected postscript write to fail"),
+            Err(err) => err.to_string(),
+        }
+    }
+
+    fn key_limit_message() -> String {
+        format!("at most {MAX_METADATA_KEY_BYTES} bytes")
+    }
+
+    fn segment_limit_message() -> String {
+        format!("at most {MAX_METADATA_SEGMENTS} metadata segments")
+    }
+
+    #[test]
+    fn metadata_limit_boundaries_roundtrip() {
+        let metadata = (0..MAX_METADATA_SEGMENTS)
+            .map(|idx| PostscriptMetadata {
+                key: format!("{idx:0>width$}", width = MAX_METADATA_KEY_BYTES),
+                segment: segment(2 + idx as u64),
+            })
+            .collect::<Vec<_>>();
+
+        let bytes = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata,
+        }
+        .write_flatbuffer_bytes()
+        .unwrap();
+
+        let postscript = Postscript::read_flatbuffer_bytes(&bytes).unwrap();
+        assert_eq!(postscript.metadata.len(), MAX_METADATA_SEGMENTS);
+        let mut total_key_bytes = 0;
+        for entry in &postscript.metadata {
+            assert_eq!(entry.key.len(), MAX_METADATA_KEY_BYTES);
+            total_key_bytes += entry.key.len();
+        }
+        assert_eq!(
+            total_key_bytes,
+            MAX_METADATA_SEGMENTS * MAX_METADATA_KEY_BYTES
+        );
+        assert!(bytes.len() <= MAX_POSTSCRIPT_SIZE as usize);
+    }
+
+    #[test]
+    fn duplicate_metadata_keys_are_rejected() {
+        let postscript = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![
+                PostscriptMetadata {
+                    key: "metadata".to_string(),
+                    segment: segment(2),
+                },
+                PostscriptMetadata {
+                    key: "metadata".to_string(),
+                    segment: segment(3),
+                },
+            ],
+        };
+
+        let read_err = read_postscript_error(&postscript);
+        assert!(read_err.contains("duplicate metadata key"));
+        assert!(read_err.contains(&key_limit_message()));
+        assert!(read_err.contains(&segment_limit_message()));
+        let write_err = write_postscript_error(&postscript);
+        assert!(write_err.contains("duplicate metadata key"));
+        assert!(write_err.contains(&key_limit_message()));
+        assert!(write_err.contains(&segment_limit_message()));
+    }
+
+    #[test]
+    fn empty_metadata_keys_are_rejected() {
+        let postscript = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![PostscriptMetadata {
+                key: String::new(),
+                segment: segment(2),
+            }],
+        };
+
+        let read_err = read_postscript_error(&postscript);
+        assert!(read_err.contains("metadata key must not be empty"));
+        let write_err = write_postscript_error(&postscript);
+        assert!(write_err.contains("metadata key must not be empty"));
+    }
+
+    #[test]
+    fn long_metadata_keys_are_rejected() {
+        let key = "é".repeat((MAX_METADATA_KEY_BYTES / "é".len()) + 1);
+        let key_len = key.len();
+        let postscript = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![PostscriptMetadata {
+                key,
+                segment: segment(2),
+            }],
+        };
+
+        for err in [
+            read_postscript_error(&postscript),
+            write_postscript_error(&postscript),
+        ] {
+            assert!(err.contains(&format!("{key_len} bytes")));
+            assert!(err.contains(&key_limit_message()));
+            assert!(err.contains(&segment_limit_message()));
+        }
+    }
+
+    #[test]
+    fn too_many_metadata_segments_are_rejected() {
+        let postscript = Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: (0..=MAX_METADATA_SEGMENTS)
+                .map(|idx| PostscriptMetadata {
+                    key: format!("metadata-{idx}"),
+                    segment: segment(2 + idx as u64),
+                })
+                .collect(),
+        };
+
+        for err in [
+            read_postscript_error(&postscript),
+            write_postscript_error(&postscript),
+        ] {
+            assert!(err.contains(&segment_limit_message()));
+            assert!(err.contains(&key_limit_message()));
+        }
+    }
+}
diff --git a/vortex-file/src/footer/serializer.rs b/vortex-file/src/footer/serializer.rs
index 65a1c3c61c6..069c12e0134 100644
--- a/vortex-file/src/footer/serializer.rs
+++ b/vortex-file/src/footer/serializer.rs
@@ -13,19 +13,23 @@ 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::SegmentSpec;
 use crate::footer::file_layout::FooterFlatBufferWriter;
 use crate::footer::postscript::Postscript;
+use crate::footer::postscript::PostscriptMetadata;
 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,54 @@ 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, _approx_byte_size)| buffers)
+    }
+
+    pub(crate) fn serialize_with_metadata(
+        mut self,
+    ) -> VortexResult<(Vec<ByteBuffer>, super::MetadataSegments, usize)> {
         let mut buffers = vec![];
 
+        let (metadata_segments, metadata_locators) = if self.metadata.is_empty() {
+            let locators = self
+                .footer
+                .metadata_segments()
+                .map(|(key, segment)| (key.to_string(), *segment))
+                .collect::<Vec<_>>();
+            let segments = locators
+                .iter()
+                .map(|(key, segment)| PostscriptMetadata {
+                    key: key.clone(),
+                    segment: PostscriptSegment::from(segment),
+                })
+                .collect();
+            (segments, locators)
+        } else {
+            let mut metadata = self.metadata.into_iter().collect::<Vec<_>>();
+            // Metadata is stored in a HashMap, so sort keys before assigning segment offsets.
+            metadata.sort_unstable_by(|(left, _), (right, _)| left.cmp(right));
+
+            let mut segments = Vec::with_capacity(metadata.len());
+            let mut locators = Vec::with_capacity(metadata.len());
+            for (key, metadata) in metadata {
+                let (metadata_buffers, segment) = write_buffer(&mut self.offset, metadata)?;
+                buffers.extend(metadata_buffers);
+                locators.push((key.clone(), SegmentSpec::from(&segment)));
+                segments.push(PostscriptMetadata { key, segment });
+            }
+            (segments, locators)
+        };
+        let metadata_storage_bytes = buffers.iter().map(ByteBuffer::len).sum::<usize>();
+
         let dtype_segment = if self.exclude_dtype {
             None
         } else {
@@ -111,6 +159,7 @@ impl FooterSerializer {
             layout: layout_segment,
             statistics: statistics_segment,
             footer: footer_segment,
+            metadata: metadata_segments,
         };
         let postscript_buffer = postscript.write_flatbuffer_bytes()?;
         if postscript_buffer.len() > MAX_POSTSCRIPT_SIZE as usize {
@@ -132,7 +181,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_locators.into(), 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,
+        }
     }
 }
 
@@ -154,3 +225,31 @@ fn write_flatbuffer<F: FlatBufferRoot + WriteFlatBuffer>(
 
     Ok((buffer.into_inner(), segment))
 }
+
+fn write_buffer(
+    offset: &mut u64,
+    buffer: ByteBuffer,
+) -> VortexResult<(Vec<ByteBuffer>, PostscriptSegment)> {
+    let length = u32::try_from(buffer.len())
+        .map_err(|_| vortex_err!("metadata segment length exceeds maximum u32"))?;
+    let alignment = buffer.alignment();
+
+    let padding = offset.next_multiple_of(*alignment as u64) - *offset;
+    let segment_offset = *offset + padding;
+
+    let segment = PostscriptSegment {
+        offset: segment_offset,
+        length,
+        alignment,
+    };
+
+    *offset += padding + u64::from(length);
+
+    let mut buffers = Vec::with_capacity(if padding == 0 { 1 } else { 2 });
+    if padding > 0 {
+        buffers.push(ByteBuffer::zeroed(padding as usize));
+    }
+    buffers.push(buffer);
+
+    Ok((buffers, segment))
+}
diff --git a/vortex-file/src/lib.rs b/vortex-file/src/lib.rs
index 4ece7d9cdab..1a1a751568c 100644
--- a/vortex-file/src/lib.rs
+++ b/vortex-file/src/lib.rs
@@ -64,6 +64,8 @@
 //! │          Segments          │  serialized array chunks and per-column
 //! │     (data & statistics)    │  statistics, in writer-chosen order
 //! ├────────────────────────────┤
+//! │   User-metadata segments   │  optional; opaque values keyed by the postscript
+//! ├────────────────────────────┤
 //! │      DType flatbuffer      │  optional; omitted via `exclude_dtype`
 //! ├────────────────────────────┤
 //! │      Layout flatbuffer     │  required; the root Layout tree
@@ -73,7 +75,7 @@
 //! │      Footer flatbuffer     │  required; dictionary-encoded segment map
 //! │                            │  and array/layout/compression/encryption specs
 //! ├────────────────────────────┤
-//! │         Postscript         │  offsets of the four footer segments above;
+//! │         Postscript         │  locators for the footer and user-metadata segments;
 //! │                            │  at most 65528 bytes
 //! ├────────────────────────────┤
 //! │     8-byte End of File     │  u16 version, u16 postscript length,
@@ -82,8 +84,12 @@
 //! ```
 //!
 //! 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 any user-defined metadata segments keyed by string, so a single read of the
+//! file tail (defaulting to 64KiB) is enough to locate and parse the footer and metadata locators.
+//! User-metadata values live in their own segments; opening a file reads none of them by default.
+//! [`VortexOpenOptions::include_metadata`] eagerly resolves every locator through the cache-backed
+//! segment source, issuing targeted reads only for values not already covered by the initial read.
+//! 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..019c59a4113 100644
--- a/vortex-file/src/multi/mod.rs
+++ b/vortex-file/src/multi/mod.rs
@@ -285,3 +285,201 @@ impl LayoutReaderFactory for VortexFileReaderFactory {
         Ok(Some(file.layout_reader()?))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fmt;
+
+    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(())
+        }
+    }
+
+    async fn assert_cached_footer_metadata_order(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();
+
+        if default_first {
+            let default = open_file(&fs, &listing, &session, &default_options).await?;
+            assert!(default.metadata_segment("key").is_none());
+            let included = open_file(&fs, &listing, &session, &metadata_options).await?;
+            assert_eq!(
+                included.metadata_segment("key").map(ByteBuffer::as_slice),
+                Some(expected.as_slice())
+            );
+        } else {
+            let included = open_file(&fs, &listing, &session, &metadata_options).await?;
+            assert_eq!(
+                included.metadata_segment("key").map(ByteBuffer::as_slice),
+                Some(expected.as_slice())
+            );
+            let default = open_file(&fs, &listing, &session, &default_options).await?;
+            assert!(default.metadata_segment("key").is_none());
+        }
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_cached_footer_default_then_metadata_is_order_independent() -> VortexResult<()> {
+        assert_cached_footer_metadata_order(true).await
+    }
+
+    #[tokio::test]
+    async fn test_cached_footer_metadata_then_default_is_order_independent() -> VortexResult<()> {
+        assert_cached_footer_metadata_order(false).await
+    }
+
+    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 fbc84888644..79e8e671240 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;
@@ -66,6 +67,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,
     /// A metrics registry for the file.
     metrics_registry: Option<Arc<dyn MetricsRegistry>>,
     /// Default labels applied to all the file's metrics
@@ -87,6 +90,7 @@ pub trait OpenOptionsSessionExt:
             file_size: None,
             dtype: None,
             footer: None,
+            include_metadata: false,
             metrics_registry: None,
             labels: Vec::default(),
             cache_layout_reader: false,
@@ -179,6 +183,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);
@@ -228,6 +251,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() {
@@ -236,11 +260,16 @@ impl VortexOpenOptions {
         };
         footer.validate_file_size(buffer.len() as u64)?;
 
-        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 {
@@ -290,19 +319,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 {
@@ -373,14 +408,15 @@ impl VortexOpenOptions {
         initial_read: &ByteBuffer,
         footer: &Footer,
     ) -> VortexResult<HashMap<SegmentId, ByteBuffer>> {
-        let first_idx = footer
-            .segment_map()
-            .partition_point(|segment| segment.offset < initial_offset);
-
         let mut initial_read_segments = HashMap::default();
 
-        for idx in first_idx..footer.segment_map().len() {
-            let segment = &footer.segment_map()[idx];
+        // Iterate `segment_specs_with_metadata` (not just the segment map) so metadata segments
+        // covered by the initial read are cached too. Metadata segments are appended and not
+        // offset-sorted, so we skip per-segment rather than partition on offset.
+        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 =
@@ -408,6 +444,36 @@ impl VortexOpenOptions {
     }
 }
 
+async fn resolve_metadata(
+    footer: &Footer,
+    segment_source: Arc<dyn SegmentSource>,
+) -> VortexResult<Arc<HashMap<String, ByteBuffer>>> {
+    let first_metadata_id = footer.segment_map().len();
+    let requests = footer
+        .metadata_segments()
+        .enumerate()
+        .map(|(index, (key, locator))| {
+            let id = u32::try_from(first_metadata_id + index).map(SegmentId::from);
+            let key = key.to_string();
+            let alignment = locator.alignment;
+            let segment_source = Arc::clone(&segment_source);
+            async move {
+                let handle = segment_source.request(id?).await?;
+                let buffer = handle.try_into_host()?.await?;
+                Ok::<_, VortexError>((
+                    key,
+                    ByteBuffer::copy_from_aligned(buffer.as_slice(), alignment),
+                ))
+            }
+        });
+    let metadata = futures::future::try_join_all(requests)
+        .await?
+        .into_iter()
+        .collect::<HashMap<_, _>>();
+
+    Ok(Arc::new(metadata))
+}
+
 #[cfg(feature = "object_store")]
 impl VortexOpenOptions {
     /// Open a Vortex file from an `object_store` backend and path.
@@ -436,6 +502,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;
@@ -470,6 +537,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> {
@@ -484,6 +552,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,
@@ -554,6 +623,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
@@ -570,6 +640,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("outside")
+            .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 e665ab18d50..a6c573232b5 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;
@@ -63,9 +64,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;
@@ -76,6 +80,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;
@@ -1761,6 +1766,177 @@ 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\"}");
+    let large = ByteBuffer::copy_from(vec![7u8; usize::from(MAX_POSTSCRIPT_SIZE) + 1024]);
+    let empty = ByteBuffer::empty_aligned(vortex_buffer::Alignment::new(16));
+    let aligned = ByteBuffer::copy_from_aligned(b"aligned", vortex_buffer::Alignment::new(64));
+
+    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", empty)
+        .with_metadata_segment("aligned", aligned.clone())
+        .write(&mut buf, array.to_array_stream())
+        .await?;
+
+    assert_eq!(summary.footer().metadata_segments().count(), 4);
+    // The footer holds only locators, so its size does not grow with the large value.
+    assert!(summary.footer().approx_byte_size().unwrap() < large.len());
+    for (_key, locator) in summary.footer().metadata_segments() {
+        assert!(locator.alignment.is_offset_aligned(locator.offset as usize));
+    }
+
+    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(), 4);
+    assert_eq!(
+        file.metadata_segment("json").map(ByteBuffer::as_slice),
+        Some(small.as_slice())
+    );
+    assert_eq!(
+        file.metadata_segment("large").map(ByteBuffer::as_slice),
+        Some(large.as_slice())
+    );
+    assert!(
+        file.metadata_segment("empty")
+            .vortex_expect("empty")
+            .is_empty()
+    );
+    let resolved_aligned = file.metadata_segment("aligned").vortex_expect("aligned");
+    assert_eq!(resolved_aligned.as_slice(), aligned.as_slice());
+    assert!(resolved_aligned.is_aligned(vortex_buffer::Alignment::new(64)));
+    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(())
+}
+
+fn with_invalid_metadata_alignment(bytes: &ByteBuffer, exponent: u8) -> 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 = old.metadata().unwrap().get(0);
+    let metadata_key = metadata.key().to_string();
+    let metadata_segment = copy_segment(metadata.segment());
+
+    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 key = fbb.create_string(&metadata_key);
+    let invalid_segment =
+        create_segment(&mut fbb, (metadata_segment.0, metadata_segment.1, exponent));
+    let metadata = fb::PostscriptMetadata::create(
+        &mut fbb,
+        &fb::PostscriptMetadataArgs {
+            key: Some(key),
+            segment: Some(invalid_segment),
+        },
+    );
+    let metadata = fbb.create_vector(&[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()
+}
+
+#[tokio::test]
+async fn test_file_metadata_malformed_alignment_returns_error_on_default_open() -> 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 = with_invalid_metadata_alignment(&ByteBuffer::from(output), 64);
+
+    for include_metadata in [false, true] {
+        let result = SESSION
+            .open_options()
+            .with_include_metadata(include_metadata)
+            .open_buffer(corrupted.clone());
+        let error = match result {
+            Ok(_) => panic!("invalid alignment exponent must fail open"),
+            Err(error) => error,
+        };
+        assert!(error.to_string().contains("Alignment exponent"));
+    }
+
+    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 80da9f4fb89..47c54e86ff9 100644
--- a/vortex-file/src/writer.rs
+++ b/vortex-file/src/writer.rs
@@ -48,6 +48,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;
@@ -55,6 +56,8 @@ use crate::MAGIC_BYTES;
 use crate::WriteStrategyBuilder;
 use crate::counting::CountingVortexWrite;
 use crate::footer::FileStatistics;
+use crate::footer::MAX_METADATA_KEY_BYTES;
+use crate::footer::MAX_METADATA_SEGMENTS;
 use crate::segments::writer::BufferedSegmentSink;
 
 /// Configure a new writer, which can eventually be used to write an [`ArrayStream`] into a sink
@@ -71,6 +74,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.
@@ -84,6 +88,7 @@ pub trait WriteOptionsSessionExt: SessionExt {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 }
@@ -98,6 +103,7 @@ impl VortexWriteOptions {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 
@@ -126,6 +132,34 @@ impl VortexWriteOptions {
         self.file_statistics = file_statistics;
         self
     }
+
+    /// Add a user-defined metadata segment (keyed, opaque bytes); a repeated key replaces the
+    /// previous value. Keys and the segment count are validated against `MAX_METADATA_*`.
+    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 {
@@ -158,6 +192,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
@@ -226,31 +262,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, 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_segments(metadata)
+            .with_approx_byte_size(approx_byte_size);
 
         for buffer in footer_buffers {
             position += buffer.len() as u64;
@@ -290,6 +327,38 @@ impl VortexWriteOptions {
     }
 }
 
+fn validate_metadata_segments(metadata: &HashMap<String, ByteBuffer>) -> VortexResult<()> {
+    if metadata.len() > MAX_METADATA_SEGMENTS {
+        vortex_bail!(
+            "Vortex files may contain at most {} metadata segments; got {} metadata segments. Metadata keys must be non-empty and at most {} bytes",
+            MAX_METADATA_SEGMENTS,
+            metadata.len(),
+            MAX_METADATA_KEY_BYTES
+        );
+    }
+
+    for key in metadata.keys() {
+        if key.is_empty() {
+            vortex_bail!(
+                "Vortex metadata keys must be non-empty and at most {} bytes; files may contain at most {} metadata segments",
+                MAX_METADATA_KEY_BYTES,
+                MAX_METADATA_SEGMENTS
+            );
+        }
+
+        let key_bytes = key.len();
+        if key_bytes > MAX_METADATA_KEY_BYTES {
+            vortex_bail!(
+                "Vortex metadata key {key:?} is {key_bytes} bytes, but keys must be at most {} bytes; files may contain at most {} metadata segments",
+                MAX_METADATA_KEY_BYTES,
+                MAX_METADATA_SEGMENTS
+            );
+        }
+    }
+
+    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..b123b0d5eeb 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,15 @@ table Postscript {
     statistics: PostscriptSegment;
     /// Segment containing the 'Footer' flatbuffer (required)
     footer: PostscriptSegment;
+    /// User-defined metadata segments keyed by string. Keys must be unique, non-empty, and at most
+    /// 64 UTF-8 bytes; readers reject postscripts that violate these limits.
+    metadata: [PostscriptMetadata];
+}
+
+/// A keyed user-defined metadata segment.
+table PostscriptMetadata {
+    key: string (required);
+    segment: PostscriptSegment (required);
 }
 
 /// A `PostscriptSegment` describes the location of a segment in the file without referencing any
diff --git a/vortex-flatbuffers/src/generated/footer.rs b/vortex-flatbuffers/src/generated/footer.rs
index 842a151edc7..62ad85542e1 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)}
   }
+  /// User-defined metadata segments keyed by string. Keys must be unique, non-empty, and at most
+  /// 64 UTF-8 bytes; readers reject postscripts that violate these limits.
+  #[inline]
+  pub fn metadata(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'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<PostscriptMetadata>>>>(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<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<PostscriptMetadata>>>>("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<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'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<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(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,123 @@ 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()
+  }
+}
+pub enum PostscriptMetadataOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// A keyed user-defined metadata segment.
+pub struct PostscriptMetadata<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for PostscriptMetadata<'a> {
+  type Inner = PostscriptMetadata<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> PostscriptMetadata<'a> {
+  pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+  pub const VT_SEGMENT: ::flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    PostscriptMetadata { _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 PostscriptMetadataArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'bldr>> {
+    let mut builder = PostscriptMetadataBuilder::new(_fbb);
+    if let Some(x) = args.segment { builder.add_segment(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>>(PostscriptMetadata::VT_KEY, None).unwrap()}
+  }
+  #[inline]
+  pub fn segment(&self) -> 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>>(PostscriptMetadata::VT_SEGMENT, None).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for PostscriptMetadata<'_> {
+  #[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<PostscriptSegment>>("segment", Self::VT_SEGMENT, true)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PostscriptMetadataArgs<'a> {
+    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub segment: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
+}
+impl<'a> Default for PostscriptMetadataArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    PostscriptMetadataArgs {
+      key: None, // required field
+      segment: None, // required field
+    }
+  }
+}
+
+pub struct PostscriptMetadataBuilder<'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> PostscriptMetadataBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PostscriptMetadata::VT_KEY, key);
+  }
+  #[inline]
+  pub fn add_segment(&mut self, segment: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(PostscriptMetadata::VT_SEGMENT, segment);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptMetadataBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PostscriptMetadataBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    self.fbb_.required(o, PostscriptMetadata::VT_KEY,"key");
+    self.fbb_.required(o, PostscriptMetadata::VT_SEGMENT,"segment");
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for PostscriptMetadata<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("PostscriptMetadata");
+      ds.field("key", &self.key());
+      ds.field("segment", &self.segment());
       ds.finish()
   }
 }
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 {