diff --git a/crates/iceberg/src/arrow/reader.rs b/crates/iceberg/src/arrow/reader.rs
index ff4cff0a64..077961d493 100644
--- a/crates/iceberg/src/arrow/reader.rs
+++ b/crates/iceberg/src/arrow/reader.rs
@@ -327,7 +327,7 @@ impl ArrowReader {
         data_file_path: &str,
         file_io: FileIO,
         should_load_page_index: bool,
-    ) -> Result<ParquetRecordBatchStreamBuilder<ArrowFileReader<impl FileRead + Sized>>> {
+    ) -> Result<ParquetRecordBatchStreamBuilder<ArrowFileReader>> {
         // Get the metadata for the Parquet file we need to read and build
         // a reader for the data within
         let parquet_file = file_io.new_input(data_file_path)?;
@@ -1312,18 +1312,18 @@ impl BoundPredicateVisitor for PredicateConverter<'_> {
 }
 
 /// ArrowFileReader is a wrapper around a FileRead that impls parquets AsyncFileReader.
-pub struct ArrowFileReader<R: FileRead> {
+pub struct ArrowFileReader {
     meta: FileMetadata,
     preload_column_index: bool,
     preload_offset_index: bool,
     preload_page_index: bool,
     metadata_size_hint: Option<usize>,
-    r: R,
+    r: Box<dyn FileRead>,
 }
 
-impl<R: FileRead> ArrowFileReader<R> {
+impl ArrowFileReader {
     /// Create a new ArrowFileReader
-    pub fn new(meta: FileMetadata, r: R) -> Self {
+    pub fn new(meta: FileMetadata, r: Box<dyn FileRead>) -> Self {
         Self {
             meta,
             preload_column_index: false,
@@ -1362,7 +1362,7 @@ impl<R: FileRead> ArrowFileReader<R> {
     }
 }
 
-impl<R: FileRead> AsyncFileReader for ArrowFileReader<R> {
+impl AsyncFileReader for ArrowFileReader {
     fn get_bytes(&mut self, range: Range<u64>) -> BoxFuture<'_, parquet::errors::Result<Bytes>> {
         Box::pin(
             self.r
diff --git a/crates/iceberg/src/io/file_io.rs b/crates/iceberg/src/io/file_io.rs
index 6e2d152ed7..48b9396bc9 100644
--- a/crates/iceberg/src/io/file_io.rs
+++ b/crates/iceberg/src/io/file_io.rs
@@ -17,14 +17,17 @@
 
 use std::any::{Any, TypeId};
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::ops::Range;
 use std::sync::Arc;
 
+use async_trait::async_trait;
 use bytes::Bytes;
-use opendal::Operator;
 use url::Url;
 
-use super::storage::Storage;
+// Re-export traits from storage module
+pub use super::storage::{Storage, StorageBuilder, StorageBuilderRegistry};
+use crate::io::STORAGE_LOCATION_SCHEME;
 use crate::{Error, ErrorKind, Result};
 
 /// FileIO implementation, used to manipulate files in underlying storage.
@@ -48,7 +51,7 @@ use crate::{Error, ErrorKind, Result};
 pub struct FileIO {
     builder: FileIOBuilder,
 
-    inner: Arc<Storage>,
+    inner: Arc<dyn Storage>,
 }
 
 impl FileIO {
@@ -89,8 +92,7 @@ impl FileIO {
     ///
     /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
     pub async fn delete(&self, path: impl AsRef<str>) -> Result<()> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        Ok(op.delete(relative_path).await?)
+        self.inner.delete(path.as_ref()).await
     }
 
     /// Remove the path and all nested dirs and files recursively.
@@ -100,8 +102,7 @@ impl FileIO {
     /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
     #[deprecated(note = "use remove_dir_all instead", since = "0.4.0")]
     pub async fn remove_all(&self, path: impl AsRef<str>) -> Result<()> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        Ok(op.remove_all(relative_path).await?)
+        self.inner.remove_dir_all(path.as_ref()).await
     }
 
     /// Remove the path and all nested dirs and files recursively.
@@ -116,13 +117,7 @@ impl FileIO {
     /// - If the path is a empty directory, this function will remove the directory itself.
     /// - If the path is a non-empty directory, this function will remove the directory and all nested files and directories.
     pub async fn remove_dir_all(&self, path: impl AsRef<str>) -> Result<()> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        let path = if relative_path.ends_with('/') {
-            relative_path.to_string()
-        } else {
-            format!("{relative_path}/")
-        };
-        Ok(op.remove_all(&path).await?)
+        self.inner.remove_dir_all(path.as_ref()).await
     }
 
     /// Check file exists.
@@ -131,8 +126,7 @@ impl FileIO {
     ///
     /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
     pub async fn exists(&self, path: impl AsRef<str>) -> Result<bool> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        Ok(op.exists(relative_path).await?)
+        self.inner.exists(path.as_ref()).await
     }
 
     /// Creates input file.
@@ -141,14 +135,7 @@ impl FileIO {
     ///
     /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
     pub fn new_input(&self, path: impl AsRef<str>) -> Result<InputFile> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        let path = path.as_ref().to_string();
-        let relative_path_pos = path.len() - relative_path.len();
-        Ok(InputFile {
-            op,
-            path,
-            relative_path_pos,
-        })
+        self.inner.new_input(path.as_ref())
     }
 
     /// Creates output file.
@@ -157,14 +144,7 @@ impl FileIO {
     ///
     /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
     pub fn new_output(&self, path: impl AsRef<str>) -> Result<OutputFile> {
-        let (op, relative_path) = self.inner.create_operator(&path)?;
-        let path = path.as_ref().to_string();
-        let relative_path_pos = path.len() - relative_path.len();
-        Ok(OutputFile {
-            op,
-            path,
-            relative_path_pos,
-        })
+        self.inner.new_output(path.as_ref())
     }
 }
 
@@ -194,6 +174,29 @@ impl Extensions {
 }
 
 /// Builder for [`FileIO`].
+///
+/// # Custom Storage Implementations
+///
+/// You can use custom storage implementations by creating a custom
+/// [`StorageBuilderRegistry`] and registering your storage builder:
+///
+/// ```rust,ignore
+/// use iceberg::io::{StorageBuilderRegistry, StorageBuilder, FileIOBuilder};
+/// use std::sync::Arc;
+///
+/// // Create your custom storage builder
+/// let my_builder = Arc::new(MyCustomStorageBuilder);
+///
+/// // Register it with a custom scheme
+/// let mut registry = StorageBuilderRegistry::new();
+/// registry.register("mycustom", my_builder);
+///
+/// // Use it to build FileIO
+/// let file_io = FileIOBuilder::new("mycustom")
+///     .with_prop("key", "value")
+///     .with_registry(registry)
+///     .build()?;
+/// ```
 #[derive(Clone, Debug)]
 pub struct FileIOBuilder {
     /// This is used to infer scheme of operator.
@@ -204,6 +207,8 @@ pub struct FileIOBuilder {
     props: HashMap<String, String>,
     /// Optional extensions to configure the underlying FileIO behavior.
     extensions: Extensions,
+    /// Optional custom registry. If None, a default registry will be created.
+    registry: Option<StorageBuilderRegistry>,
 }
 
 impl FileIOBuilder {
@@ -214,6 +219,7 @@ impl FileIOBuilder {
             scheme_str: Some(scheme_str.to_string()),
             props: HashMap::default(),
             extensions: Extensions::default(),
+            registry: None,
         }
     }
 
@@ -223,17 +229,26 @@ impl FileIOBuilder {
             scheme_str: None,
             props: HashMap::default(),
             extensions: Extensions::default(),
+            registry: None,
         }
     }
 
     /// Fetch the scheme string.
     ///
     /// The scheme_str will be empty if it's None.
-    pub fn into_parts(self) -> (String, HashMap<String, String>, Extensions) {
+    pub fn into_parts(
+        self,
+    ) -> (
+        String,
+        HashMap<String, String>,
+        Extensions,
+        Option<StorageBuilderRegistry>,
+    ) {
         (
             self.scheme_str.unwrap_or_default(),
             self.props,
             self.extensions,
+            self.registry,
         )
     }
 
@@ -271,12 +286,49 @@ impl FileIOBuilder {
         self.extensions.get::<T>()
     }
 
+    /// Sets a custom storage builder registry.
+    ///
+    /// This allows you to register custom storage implementations that can be used
+    /// when building the FileIO. If not set, a default registry with built-in
+    /// storage types will be used.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// use iceberg::io::{StorageBuilderRegistry, FileIOBuilder};
+    /// use std::sync::Arc;
+    ///
+    /// let mut registry = StorageBuilderRegistry::new();
+    /// registry.register("mycustom", Arc::new(MyCustomStorageBuilder));
+    ///
+    /// let file_io = FileIOBuilder::new("mycustom")
+    ///     .with_registry(registry)
+    ///     .build()?;
+    /// ```
+    pub fn with_registry(mut self, registry: StorageBuilderRegistry) -> Self {
+        self.registry = Some(registry);
+        self
+    }
+
     /// Builds [`FileIO`].
     pub fn build(self) -> Result<FileIO> {
-        let storage = Storage::build(self.clone())?;
+        // Use the scheme to determine the storage type
+        let scheme = self.scheme_str.clone().unwrap_or_default();
+
+        // Use custom registry if provided, otherwise create default
+        let registry = self.registry.clone().unwrap_or_default();
+
+        let builder = registry.get_builder(scheme.as_str())?;
+
+        let mut props_with_scheme = self.props.clone();
+        props_with_scheme.insert(STORAGE_LOCATION_SCHEME.to_string(), scheme);
+
+        // Build storage with props and extensions
+        let storage = builder.build(props_with_scheme, self.extensions.clone())?;
+
         Ok(FileIO {
             builder: self,
-            inner: Arc::new(storage),
+            inner: storage,
         })
     }
 }
@@ -305,7 +357,7 @@ pub trait FileRead: Send + Sync + Unpin + 'static {
 
 #[async_trait::async_trait]
 impl FileRead for opendal::Reader {
-    async fn read(&self, range: Range<u64>) -> crate::Result<Bytes> {
+    async fn read(&self, range: Range<u64>) -> Result<Bytes> {
         Ok(opendal::Reader::read(self, range).await?.to_bytes())
     }
 }
@@ -313,49 +365,53 @@ impl FileRead for opendal::Reader {
 /// Input file is used for reading from files.
 #[derive(Debug)]
 pub struct InputFile {
-    op: Operator,
-    // Absolution path of file.
+    storage: Arc<dyn Storage>,
     path: String,
-    // Relative path of file to uri, starts at [`relative_path_pos`]
-    relative_path_pos: usize,
 }
 
 impl InputFile {
+    /// Creates a new input file.
+    ///
+    /// # Arguments
+    ///
+    /// * `storage` - The storage backend to use
+    /// * `path` - Absolute path to the file
+    pub fn new(storage: Arc<dyn Storage>, path: String) -> Self {
+        Self { storage, path }
+    }
+
+    /// Returns the storage backend for this input file.
+    pub fn storage(&self) -> &Arc<dyn Storage> {
+        &self.storage
+    }
+
     /// Absolute path to root uri.
     pub fn location(&self) -> &str {
         &self.path
     }
 
     /// Check if file exists.
-    pub async fn exists(&self) -> crate::Result<bool> {
-        Ok(self.op.exists(&self.path[self.relative_path_pos..]).await?)
+    pub async fn exists(&self) -> Result<bool> {
+        self.storage.exists(&self.path).await
     }
 
     /// Fetch and returns metadata of file.
-    pub async fn metadata(&self) -> crate::Result<FileMetadata> {
-        let meta = self.op.stat(&self.path[self.relative_path_pos..]).await?;
-
-        Ok(FileMetadata {
-            size: meta.content_length(),
-        })
+    pub async fn metadata(&self) -> Result<FileMetadata> {
+        self.storage.metadata(&self.path).await
     }
 
     /// Read and returns whole content of file.
     ///
     /// For continuous reading, use [`Self::reader`] instead.
-    pub async fn read(&self) -> crate::Result<Bytes> {
-        Ok(self
-            .op
-            .read(&self.path[self.relative_path_pos..])
-            .await?
-            .to_bytes())
+    pub async fn read(&self) -> Result<Bytes> {
+        self.storage.read(&self.path).await
     }
 
     /// Creates [`FileRead`] for continuous reading.
     ///
     /// For one-time reading, use [`Self::read`] instead.
-    pub async fn reader(&self) -> crate::Result<impl FileRead + use<>> {
-        Ok(self.op.reader(&self.path[self.relative_path_pos..]).await?)
+    pub async fn reader(&self) -> Result<Box<dyn FileRead>> {
+        self.storage.reader(&self.path).await
     }
 }
 
@@ -365,17 +421,17 @@ impl InputFile {
 ///
 /// It's possible for us to remove the async_trait, but we need to figure
 /// out how to handle the object safety.
-#[async_trait::async_trait]
-pub trait FileWrite: Send + Unpin + 'static {
+#[async_trait]
+pub trait FileWrite: Send + Sync + Unpin + 'static {
     /// Write bytes to file.
     ///
     /// TODO: we can support writing non-contiguous bytes in the future.
-    async fn write(&mut self, bs: Bytes) -> crate::Result<()>;
+    async fn write(&mut self, bs: Bytes) -> Result<()>;
 
     /// Close file.
     ///
     /// Calling close on closed file will generate an error.
-    async fn close(&mut self) -> crate::Result<()>;
+    async fn close(&mut self) -> Result<()>;
 }
 
 #[async_trait::async_trait]
@@ -401,17 +457,29 @@ impl FileWrite for Box<dyn FileWrite> {
     }
 }
 
-/// Output file is used for writing to files..
+/// Output file is used for writing to files.
 #[derive(Debug)]
 pub struct OutputFile {
-    op: Operator,
-    // Absolution path of file.
+    storage: Arc<dyn Storage>,
     path: String,
-    // Relative path of file to uri, starts at [`relative_path_pos`]
-    relative_path_pos: usize,
 }
 
 impl OutputFile {
+    /// Creates a new output file.
+    ///
+    /// # Arguments
+    ///
+    /// * `storage` - The storage backend to use
+    /// * `path` - Absolute path to the file
+    pub fn new(storage: Arc<dyn Storage>, path: String) -> Self {
+        Self { storage, path }
+    }
+
+    /// Returns the storage backend for this output file.
+    pub fn storage(&self) -> &Arc<dyn Storage> {
+        &self.storage
+    }
+
     /// Relative path to root uri.
     pub fn location(&self) -> &str {
         &self.path
@@ -419,23 +487,19 @@ impl OutputFile {
 
     /// Checks if file exists.
     pub async fn exists(&self) -> Result<bool> {
-        Ok(self.op.exists(&self.path[self.relative_path_pos..]).await?)
+        self.storage.exists(&self.path).await
     }
 
     /// Deletes file.
     ///
     /// If the file does not exist, it will not return error.
     pub async fn delete(&self) -> Result<()> {
-        Ok(self.op.delete(&self.path[self.relative_path_pos..]).await?)
+        self.storage.delete(&self.path).await
     }
 
     /// Converts into [`InputFile`].
     pub fn to_input_file(self) -> InputFile {
-        InputFile {
-            op: self.op,
-            path: self.path,
-            relative_path_pos: self.relative_path_pos,
-        }
+        InputFile::new(self.storage, self.path)
     }
 
     /// Create a new output file with given bytes.
@@ -445,9 +509,7 @@ impl OutputFile {
     /// Calling `write` will overwrite the file if it exists.
     /// For continuous writing, use [`Self::writer`].
     pub async fn write(&self, bs: Bytes) -> crate::Result<()> {
-        let mut writer = self.writer().await?;
-        writer.write(bs).await?;
-        writer.close().await
+        self.storage.write(self.path.as_str(), bs).await
     }
 
     /// Creates output file for continuous writing.
@@ -456,24 +518,129 @@ impl OutputFile {
     ///
     /// For one-time writing, use [`Self::write`] instead.
     pub async fn writer(&self) -> crate::Result<Box<dyn FileWrite>> {
-        Ok(Box::new(
-            self.op.writer(&self.path[self.relative_path_pos..]).await?,
-        ))
+        Ok(Box::new(self.storage.writer(&self.path).await?))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
     use std::fs::{File, create_dir_all};
     use std::io::Write;
     use std::path::Path;
+    use std::sync::{Arc, Mutex, MutexGuard};
 
+    use async_trait::async_trait;
     use bytes::Bytes;
     use futures::AsyncReadExt;
     use futures::io::AllowStdIo;
     use tempfile::TempDir;
 
     use super::{FileIO, FileIOBuilder};
+    use crate::io::{
+        Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile,
+        STORAGE_LOCATION_SCHEME, Storage, StorageBuilder, StorageBuilderRegistry,
+    };
+    use crate::{Error, ErrorKind, Result};
+
+    // Test storage implementation that tracks write operations
+    #[derive(Debug, Clone)]
+    struct TestStorage {
+        written: Arc<Mutex<Vec<String>>>,
+        received_props: HashMap<String, String>,
+    }
+
+    #[allow(dead_code)]
+    impl TestStorage {
+        pub fn written(&self) -> MutexGuard<'_, Vec<String>> {
+            self.written.lock().unwrap()
+        }
+
+        pub fn received_props(&self) -> &HashMap<String, String> {
+            &self.received_props
+        }
+    }
+
+    #[async_trait]
+    impl Storage for TestStorage {
+        async fn exists(&self, _path: &str) -> Result<bool> {
+            Ok(true)
+        }
+
+        async fn metadata(&self, _path: &str) -> Result<FileMetadata> {
+            Ok(FileMetadata { size: 42 })
+        }
+
+        async fn read(&self, _path: &str) -> Result<Bytes> {
+            Ok(Bytes::from("test data"))
+        }
+
+        async fn reader(&self, _path: &str) -> Result<Box<dyn FileRead>> {
+            Err(Error::new(
+                ErrorKind::FeatureUnsupported,
+                "TestStorage does not support reader",
+            ))
+        }
+
+        async fn write(&self, path: &str, _bs: Bytes) -> Result<()> {
+            self.written.lock().unwrap().push(path.to_string());
+            Ok(())
+        }
+
+        async fn writer(&self, _path: &str) -> Result<Box<dyn FileWrite>> {
+            Err(Error::new(
+                ErrorKind::FeatureUnsupported,
+                "TestStorage does not support writer",
+            ))
+        }
+
+        async fn delete(&self, _path: &str) -> Result<()> {
+            Ok(())
+        }
+
+        async fn remove_dir_all(&self, _path: &str) -> Result<()> {
+            Ok(())
+        }
+
+        fn new_input(&self, path: &str) -> Result<InputFile> {
+            Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+        }
+
+        fn new_output(&self, path: &str) -> Result<OutputFile> {
+            Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+        }
+    }
+
+    // Test storage builder
+    #[derive(Debug)]
+    struct TestStorageBuilder {
+        written: Arc<Mutex<Vec<String>>>,
+        received_props: Arc<Mutex<HashMap<String, String>>>,
+    }
+
+    impl TestStorageBuilder {
+        pub fn written(&self) -> MutexGuard<'_, Vec<String>> {
+            self.written.lock().unwrap()
+        }
+
+        pub fn received_props(&self) -> MutexGuard<'_, HashMap<String, String>> {
+            self.received_props.lock().unwrap()
+        }
+    }
+
+    impl StorageBuilder for TestStorageBuilder {
+        fn build(
+            &self,
+            props: HashMap<String, String>,
+            _extensions: Extensions,
+        ) -> Result<Arc<dyn Storage>> {
+            *self.received_props.lock().unwrap() = props.clone();
+            Ok(Arc::new(TestStorage {
+                written: self.written.clone(),
+                received_props: props,
+            }))
+        }
+    }
 
     fn create_local_file_io() -> FileIO {
         FileIOBuilder::new_fs_io().build().unwrap()
@@ -617,4 +784,117 @@ mod tests {
         io.delete(&path).await.unwrap();
         assert!(!io.exists(&path).await.unwrap());
     }
+
+    #[test]
+    fn test_custom_registry() {
+        // Create a custom registry and register test storage
+        let builder = Arc::new(TestStorageBuilder {
+            written: Arc::new(Mutex::new(Vec::new())),
+            received_props: Arc::new(Mutex::new(HashMap::new())),
+        });
+
+        let mut registry = StorageBuilderRegistry::new();
+        registry.register("test", builder.clone());
+
+        // Build FileIO with custom storage
+        let file_io = FileIOBuilder::new("test")
+            .with_registry(registry)
+            .build()
+            .unwrap();
+
+        // Verify we can create files with the custom storage
+        assert!(file_io.new_output("test://test.txt").is_ok());
+        assert!(file_io.new_input("test://test.txt").is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_custom_registry_operations() {
+        // Create test storage with write tracking
+        let builder = Arc::new(TestStorageBuilder {
+            written: Arc::new(Mutex::new(Vec::new())),
+            received_props: Arc::new(Mutex::new(HashMap::new())),
+        });
+
+        let mut registry = StorageBuilderRegistry::new();
+        registry.register("test", builder.clone());
+
+        // Build FileIO with test storage
+        let file_io = FileIOBuilder::new("test")
+            .with_registry(registry)
+            .build()
+            .unwrap();
+
+        // Perform operations
+        let output = file_io.new_output("test://bucket/file.txt").unwrap();
+        output.write(Bytes::from("test")).await.unwrap();
+
+        let input = file_io.new_input("test://bucket/file.txt").unwrap();
+        let data = input.read().await.unwrap();
+        assert_eq!(data, Bytes::from("test data"));
+
+        let metadata = input.metadata().await.unwrap();
+        assert_eq!(metadata.size, 42);
+
+        // Verify write was tracked
+        let tracked = builder.written();
+        assert_eq!(tracked.len(), 1);
+        assert_eq!(tracked[0], "test://bucket/file.txt");
+    }
+
+    #[test]
+    fn test_scheme_and_props_propagation() {
+        // Create test storage that captures props
+        let builder = Arc::new(TestStorageBuilder {
+            written: Arc::new(Mutex::new(Vec::new())),
+            received_props: Arc::new(Mutex::new(HashMap::new())),
+        });
+
+        let mut registry = StorageBuilderRegistry::new();
+        registry.register("myscheme", builder.clone());
+
+        // Build FileIO with custom scheme and additional props
+        let file_io = FileIOBuilder::new("myscheme")
+            .with_prop("custom.prop", "custom_value")
+            .with_registry(registry)
+            .build()
+            .unwrap();
+
+        // Verify the storage was created
+        assert!(file_io.new_output("myscheme://test.txt").is_ok());
+
+        // Verify the scheme was propagated to the builder
+        let props = builder.received_props();
+        assert_eq!(
+            props.get(STORAGE_LOCATION_SCHEME),
+            Some(&"myscheme".to_string())
+        );
+        // Verify custom props were also passed
+        assert_eq!(props.get("custom.prop"), Some(&"custom_value".to_string()));
+    }
+
+    #[test]
+    fn test_into_parts_includes_registry() {
+        let registry = StorageBuilderRegistry::new();
+
+        let builder = FileIOBuilder::new("memory")
+            .with_prop("key", "value")
+            .with_registry(registry.clone());
+
+        let (scheme, props, _extensions, returned_registry) = builder.into_parts();
+
+        assert_eq!(scheme, "memory");
+        assert_eq!(props.get("key"), Some(&"value".to_string()));
+        assert!(returned_registry.is_some());
+    }
+
+    #[test]
+    fn test_into_parts_without_registry() {
+        let builder = FileIOBuilder::new("memory").with_prop("key", "value");
+
+        let (scheme, props, _extensions, returned_registry) = builder.into_parts();
+
+        assert_eq!(scheme, "memory");
+        assert_eq!(props.get("key"), Some(&"value".to_string()));
+        assert!(returned_registry.is_none());
+    }
 }
diff --git a/crates/iceberg/src/io/mod.rs b/crates/iceberg/src/io/mod.rs
index 5eb5964345..209be5321d 100644
--- a/crates/iceberg/src/io/mod.rs
+++ b/crates/iceberg/src/io/mod.rs
@@ -70,8 +70,12 @@ mod file_io;
 mod storage;
 
 pub use file_io::*;
+pub use storage::{Storage, StorageBuilder, StorageBuilderRegistry};
 pub(crate) mod object_cache;
 
+/// Property key used to pass the scheme string from FileIOBuilder to StorageBuilder.
+pub const STORAGE_LOCATION_SCHEME: &str = "iceberg.storage.location.scheme";
+
 #[cfg(feature = "storage-azdls")]
 mod storage_azdls;
 #[cfg(feature = "storage-fs")]
@@ -87,12 +91,8 @@ mod storage_s3;
 
 #[cfg(feature = "storage-azdls")]
 pub use storage_azdls::*;
-#[cfg(feature = "storage-fs")]
-use storage_fs::*;
 #[cfg(feature = "storage-gcs")]
 pub use storage_gcs::*;
-#[cfg(feature = "storage-memory")]
-use storage_memory::*;
 #[cfg(feature = "storage-oss")]
 pub use storage_oss::*;
 #[cfg(feature = "storage-s3")]
diff --git a/crates/iceberg/src/io/storage.rs b/crates/iceberg/src/io/storage.rs
index 3de4f10dbf..03f5b77155 100644
--- a/crates/iceberg/src/io/storage.rs
+++ b/crates/iceberg/src/io/storage.rs
@@ -15,220 +15,296 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Storage traits and implementations for Iceberg.
+//!
+//! This module provides the core storage abstraction used throughout Iceberg Rust.
+//! Storage implementations handle reading and writing files across different backends
+//! (S3, GCS, Azure, local filesystem, etc.).
+
+use std::collections::HashMap;
+use std::fmt::Debug;
 use std::sync::Arc;
 
-use opendal::layers::RetryLayer;
-#[cfg(feature = "storage-azdls")]
-use opendal::services::AzdlsConfig;
-#[cfg(feature = "storage-gcs")]
-use opendal::services::GcsConfig;
-#[cfg(feature = "storage-oss")]
-use opendal::services::OssConfig;
-#[cfg(feature = "storage-s3")]
-use opendal::services::S3Config;
-use opendal::{Operator, Scheme};
-
-#[cfg(feature = "storage-azdls")]
-use super::AzureStorageScheme;
-use super::FileIOBuilder;
-#[cfg(feature = "storage-s3")]
-use crate::io::CustomAwsCredentialLoader;
-use crate::{Error, ErrorKind};
-
-/// The storage carries all supported storage services in iceberg
-#[derive(Debug)]
-pub(crate) enum Storage {
-    #[cfg(feature = "storage-memory")]
-    Memory(Operator),
-    #[cfg(feature = "storage-fs")]
-    LocalFs,
-    /// Expects paths of the form `s3[a]://<bucket>/<path>`.
-    #[cfg(feature = "storage-s3")]
-    S3 {
-        /// s3 storage could have `s3://` and `s3a://`.
-        /// Storing the scheme string here to return the correct path.
-        configured_scheme: String,
-        config: Arc<S3Config>,
-        customized_credential_load: Option<CustomAwsCredentialLoader>,
-    },
-    #[cfg(feature = "storage-gcs")]
-    Gcs { config: Arc<GcsConfig> },
-    #[cfg(feature = "storage-oss")]
-    Oss { config: Arc<OssConfig> },
-    /// Expects paths of the form
-    /// `abfs[s]://<filesystem>@<account>.dfs.<endpoint-suffix>/<path>` or
-    /// `wasb[s]://<container>@<account>.blob.<endpoint-suffix>/<path>`.
-    #[cfg(feature = "storage-azdls")]
-    Azdls {
-        /// Because Azdls accepts multiple possible schemes, we store the full
-        /// passed scheme here to later validate schemes passed via paths.
-        configured_scheme: AzureStorageScheme,
-        config: Arc<AzdlsConfig>,
-    },
-}
+use async_trait::async_trait;
+use bytes::Bytes;
 
-impl Storage {
-    /// Convert iceberg config to opendal config.
-    pub(crate) fn build(file_io_builder: FileIOBuilder) -> crate::Result<Self> {
-        let (scheme_str, props, extensions) = file_io_builder.into_parts();
-        let scheme = Self::parse_scheme(&scheme_str)?;
-
-        match scheme {
-            #[cfg(feature = "storage-memory")]
-            Scheme::Memory => Ok(Self::Memory(super::memory_config_build()?)),
-            #[cfg(feature = "storage-fs")]
-            Scheme::Fs => Ok(Self::LocalFs),
-            #[cfg(feature = "storage-s3")]
-            Scheme::S3 => Ok(Self::S3 {
-                configured_scheme: scheme_str,
-                config: super::s3_config_parse(props)?.into(),
-                customized_credential_load: extensions
-                    .get::<CustomAwsCredentialLoader>()
-                    .map(Arc::unwrap_or_clone),
-            }),
-            #[cfg(feature = "storage-gcs")]
-            Scheme::Gcs => Ok(Self::Gcs {
-                config: super::gcs_config_parse(props)?.into(),
-            }),
-            #[cfg(feature = "storage-oss")]
-            Scheme::Oss => Ok(Self::Oss {
-                config: super::oss_config_parse(props)?.into(),
-            }),
-            #[cfg(feature = "storage-azdls")]
-            Scheme::Azdls => {
-                let scheme = scheme_str.parse::<AzureStorageScheme>()?;
-                Ok(Self::Azdls {
-                    config: super::azdls_config_parse(props)?.into(),
-                    configured_scheme: scheme,
-                })
-            }
-            // Update doc on [`FileIO`] when adding new schemes.
-            _ => Err(Error::new(
-                ErrorKind::FeatureUnsupported,
-                format!("Constructing file io from scheme: {scheme} not supported now",),
-            )),
-        }
-    }
+use super::{Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile};
+use crate::Result;
+
+/// Trait for storage operations in Iceberg.
+///
+/// This trait defines the interface for all storage backends. Implementations
+/// provide access to different storage systems like S3, GCS, Azure, local filesystem, etc.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use iceberg::io::Storage;
+///
+/// async fn example(storage: Arc<dyn Storage>) -> Result<()> {
+///     // Check if file exists
+///     if storage.exists("s3://bucket/path/file.parquet").await? {
+///         // Read file
+///         let data = storage.read("s3://bucket/path/file.parquet").await?;
+///     }
+///     Ok(())
+/// }
+/// ```
+#[async_trait]
+pub trait Storage: Debug + Send + Sync {
+    /// Check if a file exists at the given path
+    async fn exists(&self, path: &str) -> Result<bool>;
+
+    /// Get metadata from an input path
+    async fn metadata(&self, path: &str) -> Result<FileMetadata>;
+
+    /// Read bytes from a path
+    async fn read(&self, path: &str) -> Result<Bytes>;
+
+    /// Get FileRead from a path
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>>;
+
+    /// Write bytes to an output path
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()>;
+
+    /// Get FileWrite from a path
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>>;
+
+    /// Delete a file at the given path
+    async fn delete(&self, path: &str) -> Result<()>;
+
+    /// Remove a directory and all its contents recursively
+    async fn remove_dir_all(&self, path: &str) -> Result<()>;
+
+    /// Create a new input file for reading
+    fn new_input(&self, path: &str) -> Result<InputFile>;
+
+    /// Create a new output file for writing
+    fn new_output(&self, path: &str) -> Result<OutputFile>;
+}
 
-    /// Creates operator from path.
+/// Common interface for all storage builders.
+///
+/// Storage builders are responsible for creating storage instances from configuration
+/// properties and extensions. Each storage backend (S3, GCS, etc.) provides its own
+/// builder implementation.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use iceberg::io::{StorageBuilder, Extensions};
+/// use std::collections::HashMap;
+///
+/// struct MyStorageBuilder;
+///
+/// impl StorageBuilder for MyStorageBuilder {
+///     fn build(
+///         &self,
+///         props: HashMap<String, String>,
+///         extensions: Extensions,
+///     ) -> Result<Arc<dyn Storage>> {
+///         // Parse configuration and create storage
+///         Ok(Arc::new(MyStorage::new(props)?))
+///     }
+/// }
+/// ```
+pub trait StorageBuilder: Debug + Send + Sync {
+    /// Create a new storage instance with the given properties and extensions.
     ///
     /// # Arguments
     ///
-    /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
+    /// * `props` - Configuration properties for the storage backend
+    /// * `extensions` - Additional extensions (e.g., custom credential loaders)
     ///
     /// # Returns
     ///
-    /// The return value consists of two parts:
-    ///
-    /// * An [`opendal::Operator`] instance used to operate on file.
-    /// * Relative path to the root uri of [`opendal::Operator`].
-    pub(crate) fn create_operator<'a>(
+    /// An `Arc<dyn Storage>` that can be used for file operations.
+    fn build(
         &self,
-        path: &'a impl AsRef<str>,
-    ) -> crate::Result<(Operator, &'a str)> {
-        let path = path.as_ref();
-        let (operator, relative_path): (Operator, &str) = match self {
-            #[cfg(feature = "storage-memory")]
-            Storage::Memory(op) => {
-                if let Some(stripped) = path.strip_prefix("memory:/") {
-                    Ok::<_, crate::Error>((op.clone(), stripped))
-                } else {
-                    Ok::<_, crate::Error>((op.clone(), &path[1..]))
-                }
-            }
-            #[cfg(feature = "storage-fs")]
-            Storage::LocalFs => {
-                let op = super::fs_config_build()?;
-
-                if let Some(stripped) = path.strip_prefix("file:/") {
-                    Ok::<_, crate::Error>((op, stripped))
-                } else {
-                    Ok::<_, crate::Error>((op, &path[1..]))
-                }
-            }
-            #[cfg(feature = "storage-s3")]
-            Storage::S3 {
-                configured_scheme,
-                config,
-                customized_credential_load,
-            } => {
-                let op = super::s3_config_build(config, customized_credential_load, path)?;
-                let op_info = op.info();
-
-                // Check prefix of s3 path.
-                let prefix = format!("{}://{}/", configured_scheme, op_info.name());
-                if path.starts_with(&prefix) {
-                    Ok((op, &path[prefix.len()..]))
-                } else {
-                    Err(Error::new(
-                        ErrorKind::DataInvalid,
-                        format!("Invalid s3 url: {}, should start with {}", path, prefix),
-                    ))
-                }
-            }
-            #[cfg(feature = "storage-gcs")]
-            Storage::Gcs { config } => {
-                let operator = super::gcs_config_build(config, path)?;
-                let prefix = format!("gs://{}/", operator.info().name());
-                if path.starts_with(&prefix) {
-                    Ok((operator, &path[prefix.len()..]))
-                } else {
-                    Err(Error::new(
-                        ErrorKind::DataInvalid,
-                        format!("Invalid gcs url: {}, should start with {}", path, prefix),
-                    ))
-                }
-            }
-            #[cfg(feature = "storage-oss")]
-            Storage::Oss { config } => {
-                let op = super::oss_config_build(config, path)?;
-
-                // Check prefix of oss path.
-                let prefix = format!("oss://{}/", op.info().name());
-                if path.starts_with(&prefix) {
-                    Ok((op, &path[prefix.len()..]))
-                } else {
-                    Err(Error::new(
-                        ErrorKind::DataInvalid,
-                        format!("Invalid oss url: {}, should start with {}", path, prefix),
-                    ))
-                }
-            }
-            #[cfg(feature = "storage-azdls")]
-            Storage::Azdls {
-                configured_scheme,
-                config,
-            } => super::azdls_create_operator(path, config, configured_scheme),
-            #[cfg(all(
-                not(feature = "storage-s3"),
-                not(feature = "storage-fs"),
-                not(feature = "storage-gcs"),
-                not(feature = "storage-oss"),
-                not(feature = "storage-azdls"),
-            ))]
-            _ => Err(Error::new(
-                ErrorKind::FeatureUnsupported,
-                "No storage service has been enabled",
-            )),
-        }?;
-
-        // Transient errors are common for object stores; however there's no
-        // harm in retrying temporary failures for other storage backends as well.
-        let operator = operator.layer(RetryLayer::new());
-
-        Ok((operator, relative_path))
-    }
+        props: HashMap<String, String>,
+        extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>>;
+}
+
+/// A registry of storage builders.
+///
+/// The registry allows you to register custom storage builders for different URI schemes.
+/// By default, it includes builders for all enabled storage features.
+///
+/// # Example
+///
+/// ```rust
+/// use iceberg::io::StorageBuilderRegistry;
+///
+/// // Create a new registry with default builders
+/// let registry = StorageBuilderRegistry::new();
+///
+/// // Get supported storage types
+/// let types = registry.supported_types();
+/// println!("Supported storage types: {:?}", types);
+///
+/// // Get a builder for a specific scheme
+/// # #[cfg(feature = "storage-memory")]
+/// # {
+/// let builder = registry.get_builder("memory").unwrap();
+/// # }
+/// ```
+///
+/// You can also register custom storage builders:
+///
+/// ```rust,ignore
+/// use std::sync::Arc;
+/// use iceberg::io::{StorageBuilderRegistry, StorageBuilder};
+///
+/// let mut registry = StorageBuilderRegistry::new();
+///
+/// // Register a custom storage builder
+/// registry.register("custom", Arc::new(MyCustomStorageBuilder));
+/// ```
+#[derive(Debug, Clone)]
+pub struct StorageBuilderRegistry {
+    builders: HashMap<String, Arc<dyn StorageBuilder>>,
+}
+
+impl StorageBuilderRegistry {
+    /// Create a new storage registry with default builders based on enabled features.
+    pub fn new() -> Self {
+        let mut builders: HashMap<String, Arc<dyn StorageBuilder>> = HashMap::new();
+
+        #[cfg(feature = "storage-memory")]
+        {
+            use crate::io::storage_memory::OpenDALMemoryStorageBuilder;
+            let builder = Arc::new(OpenDALMemoryStorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("memory".to_string(), builder);
+        }
+
+        #[cfg(feature = "storage-fs")]
+        {
+            use crate::io::storage_fs::OpenDALFsStorageBuilder;
+            let builder = Arc::new(OpenDALFsStorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("file".to_string(), builder.clone());
+            builders.insert("".to_string(), builder);
+        }
+
+        #[cfg(feature = "storage-s3")]
+        {
+            use crate::io::storage_s3::OpenDALS3StorageBuilder;
+            let builder = Arc::new(OpenDALS3StorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("s3".to_string(), builder.clone());
+            builders.insert("s3a".to_string(), builder);
+        }
+
+        #[cfg(feature = "storage-gcs")]
+        {
+            use crate::io::storage_gcs::OpenDALGcsStorageBuilder;
+            let builder = Arc::new(OpenDALGcsStorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("gs".to_string(), builder.clone());
+            builders.insert("gcs".to_string(), builder);
+        }
 
-    /// Parse scheme.
-    fn parse_scheme(scheme: &str) -> crate::Result<Scheme> {
-        match scheme {
-            "memory" => Ok(Scheme::Memory),
-            "file" | "" => Ok(Scheme::Fs),
-            "s3" | "s3a" => Ok(Scheme::S3),
-            "gs" | "gcs" => Ok(Scheme::Gcs),
-            "oss" => Ok(Scheme::Oss),
-            "abfss" | "abfs" | "wasbs" | "wasb" => Ok(Scheme::Azdls),
-            s => Ok(s.parse::<Scheme>()?),
+        #[cfg(feature = "storage-oss")]
+        {
+            use crate::io::storage_oss::OpenDALOssStorageBuilder;
+            let builder = Arc::new(OpenDALOssStorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("oss".to_string(), builder);
         }
+
+        #[cfg(feature = "storage-azdls")]
+        {
+            use crate::io::storage_azdls::OpenDALAzdlsStorageBuilder;
+            let builder = Arc::new(OpenDALAzdlsStorageBuilder) as Arc<dyn StorageBuilder>;
+            builders.insert("abfs".to_string(), builder.clone());
+            builders.insert("abfss".to_string(), builder.clone());
+            builders.insert("wasb".to_string(), builder.clone());
+            builders.insert("wasbs".to_string(), builder);
+        }
+
+        Self { builders }
+    }
+
+    /// Register a custom storage builder for a given scheme.
+    pub fn register(&mut self, scheme: impl Into<String>, builder: Arc<dyn StorageBuilder>) {
+        self.builders.insert(scheme.into(), builder);
+    }
+
+    /// Get a storage builder by scheme.
+    pub fn get_builder(&self, scheme: &str) -> Result<Arc<dyn StorageBuilder>> {
+        let key = scheme.trim();
+        self.builders
+            .iter()
+            .find(|(k, _)| k.eq_ignore_ascii_case(key))
+            .map(|(_, builder)| builder.clone())
+            .ok_or_else(|| {
+                use crate::{Error, ErrorKind};
+                Error::new(
+                    ErrorKind::FeatureUnsupported,
+                    format!(
+                        "Unsupported storage type: {}. Supported types: {}",
+                        scheme,
+                        self.supported_types().join(", ")
+                    ),
+                )
+            })
+    }
+
+    /// Return the list of supported storage types.
+    pub fn supported_types(&self) -> Vec<String> {
+        self.builders.keys().cloned().collect()
+    }
+}
+
+impl Default for StorageBuilderRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_storage_builder_registry_new() {
+        let registry = StorageBuilderRegistry::new();
+        let types = registry.supported_types();
+
+        // At least one storage type should be available
+        assert!(!types.is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "storage-memory")]
+    fn test_storage_builder_registry_get_builder() {
+        let registry = StorageBuilderRegistry::new();
+
+        // Should be able to get memory storage builder
+        let builder = registry.get_builder("memory");
+        assert!(builder.is_ok());
+
+        // Should be case-insensitive
+        let builder = registry.get_builder("MEMORY");
+        assert!(builder.is_ok());
+    }
+
+    #[test]
+    fn test_storage_builder_registry_unsupported_type() {
+        let registry = StorageBuilderRegistry::new();
+
+        // Should return error for unsupported type
+        let result = registry.get_builder("unsupported");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "storage-memory")]
+    fn test_storage_builder_registry_clone() {
+        let registry = StorageBuilderRegistry::new();
+        let cloned = registry.clone();
+
+        // Both should have the same builders
+        assert_eq!(
+            registry.supported_types().len(),
+            cloned.supported_types().len()
+        );
     }
 }
diff --git a/crates/iceberg/src/io/storage_azdls.rs b/crates/iceberg/src/io/storage_azdls.rs
index fe12167f6f..f0a85e44b1 100644
--- a/crates/iceberg/src/io/storage_azdls.rs
+++ b/crates/iceberg/src/io/storage_azdls.rs
@@ -18,11 +18,18 @@
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::str::FromStr;
+use std::sync::Arc;
 
-use opendal::Configurator;
+use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::services::AzdlsConfig;
+use opendal::{Configurator, Operator};
 use url::Url;
 
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, STORAGE_LOCATION_SCHEME,
+    Storage, StorageBuilder,
+};
 use crate::{Error, ErrorKind, Result, ensure_data_valid};
 
 /// A connection string.
@@ -125,7 +132,7 @@ pub(crate) fn azdls_create_operator<'a>(
 ///   paths are expected to contain the `dfs` storage service.
 /// - `wasb[s]` is used to refer to files in Blob Storage directly; paths are
 ///   expected to contain the `blob` storage service.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub(crate) enum AzureStorageScheme {
     Abfs,
     Abfss,
@@ -597,3 +604,111 @@ mod tests {
         }
     }
 }
+
+/// Azure Data Lake Storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALAzdlsStorage {
+    /// Because Azdls accepts multiple possible schemes, we store the full
+    /// passed scheme here to later validate schemes passed via paths.
+    configured_scheme: AzureStorageScheme,
+    config: Arc<AzdlsConfig>,
+}
+
+impl OpenDALAzdlsStorage {
+    /// Creates operator from path.
+    fn create_operator<'a>(&self, path: &'a str) -> Result<(Operator, &'a str)> {
+        let (op, relative_path) =
+            azdls_create_operator(path, &self.config, &self.configured_scheme)?;
+        let op = op.layer(opendal::layers::RetryLayer::new());
+        Ok((op, relative_path))
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALAzdlsStorage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let meta = op.stat(relative_path).await?;
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for Azure Data Lake Storage
+#[derive(Debug)]
+pub struct OpenDALAzdlsStorageBuilder;
+
+impl StorageBuilder for OpenDALAzdlsStorageBuilder {
+    fn build(
+        &self,
+        props: HashMap<String, String>,
+        _extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        // Get the scheme string from the props or use default
+        let scheme_str = props
+            .get(STORAGE_LOCATION_SCHEME)
+            .cloned()
+            .unwrap_or_else(|| "abfs".to_string());
+
+        // Parse the scheme
+        let scheme = scheme_str.parse::<AzureStorageScheme>()?;
+
+        // Parse Azdls config from props
+        let config = azdls_config_parse(props)?;
+
+        Ok(Arc::new(OpenDALAzdlsStorage {
+            configured_scheme: scheme,
+            config: Arc::new(config),
+        }))
+    }
+}
diff --git a/crates/iceberg/src/io/storage_fs.rs b/crates/iceberg/src/io/storage_fs.rs
index d3e121a085..0b612351f7 100644
--- a/crates/iceberg/src/io/storage_fs.rs
+++ b/crates/iceberg/src/io/storage_fs.rs
@@ -15,10 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::Operator;
 use opendal::services::FsConfig;
 
 use crate::Result;
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, Storage, StorageBuilder,
+};
 
 /// Build new opendal operator from give path.
 pub(crate) fn fs_config_build() -> Result<Operator> {
@@ -27,3 +35,99 @@ pub(crate) fn fs_config_build() -> Result<Operator> {
 
     Ok(Operator::from_config(cfg)?.finish())
 }
+
+/// Filesystem storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALFsStorage;
+
+impl OpenDALFsStorage {
+    /// Extract relative path from file:// URLs
+    fn extract_relative_path<'a>(&self, path: &'a str) -> &'a str {
+        if let Some(stripped) = path.strip_prefix("file:/") {
+            stripped
+        } else {
+            &path[1..]
+        }
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALFsStorage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        Ok(op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        let meta = op.stat(relative_path).await?;
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        Ok(op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        Ok(Box::new(op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        Ok(Box::new(op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        Ok(op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let relative_path = self.extract_relative_path(path);
+        let op = fs_config_build()?;
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for OpenDAL Filesystem storage
+#[derive(Debug)]
+pub struct OpenDALFsStorageBuilder;
+
+impl StorageBuilder for OpenDALFsStorageBuilder {
+    fn build(
+        &self,
+        _props: HashMap<String, String>,
+        _extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        Ok(Arc::new(OpenDALFsStorage))
+    }
+}
diff --git a/crates/iceberg/src/io/storage_gcs.rs b/crates/iceberg/src/io/storage_gcs.rs
index 8c3d914c86..f3dc0212a9 100644
--- a/crates/iceberg/src/io/storage_gcs.rs
+++ b/crates/iceberg/src/io/storage_gcs.rs
@@ -17,12 +17,18 @@
 //! Google Cloud Storage properties
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
+use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::Operator;
 use opendal::services::GcsConfig;
 use url::Url;
 
-use crate::io::is_truthy;
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, Storage, StorageBuilder,
+    is_truthy,
+};
 use crate::{Error, ErrorKind, Result};
 
 // Reference: https://github.com/apache/iceberg/blob/main/gcp/src/main/java/org/apache/iceberg/gcp/GCPProperties.java
@@ -104,3 +110,104 @@ pub(crate) fn gcs_config_build(cfg: &GcsConfig, path: &str) -> Result<Operator>
     cfg.bucket = bucket.to_string();
     Ok(Operator::from_config(cfg)?.finish())
 }
+
+/// GCS storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALGcsStorage {
+    config: Arc<GcsConfig>,
+}
+
+impl OpenDALGcsStorage {
+    /// Creates operator from path.
+    fn create_operator<'a>(&self, path: &'a str) -> Result<(Operator, &'a str)> {
+        let operator = gcs_config_build(&self.config, path)?;
+        let prefix = format!("gs://{}/", operator.info().name());
+
+        if path.starts_with(&prefix) {
+            let op = operator.layer(opendal::layers::RetryLayer::new());
+            Ok((op, &path[prefix.len()..]))
+        } else {
+            Err(Error::new(
+                ErrorKind::DataInvalid,
+                format!("Invalid gcs url: {}, should start with {}", path, prefix),
+            ))
+        }
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALGcsStorage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let meta = op.stat(relative_path).await?;
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for OpenDAL GCS storage
+#[derive(Debug)]
+pub struct OpenDALGcsStorageBuilder;
+
+impl StorageBuilder for OpenDALGcsStorageBuilder {
+    fn build(
+        &self,
+        props: HashMap<String, String>,
+        _extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        let cfg = gcs_config_parse(props)?;
+        Ok(Arc::new(OpenDALGcsStorage {
+            config: Arc::new(cfg),
+        }))
+    }
+}
diff --git a/crates/iceberg/src/io/storage_memory.rs b/crates/iceberg/src/io/storage_memory.rs
index b8023717b6..b72a0b7abc 100644
--- a/crates/iceberg/src/io/storage_memory.rs
+++ b/crates/iceberg/src/io/storage_memory.rs
@@ -15,11 +15,107 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::Operator;
 use opendal::services::MemoryConfig;
 
 use crate::Result;
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, Storage, StorageBuilder,
+};
+
+/// Memory storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALMemoryStorage {
+    op: Operator,
+}
+
+impl OpenDALMemoryStorage {
+    /// Extract relative path from memory:// URLs
+    fn extract_relative_path<'a>(&self, path: &'a str) -> &'a str {
+        if let Some(stripped) = path.strip_prefix("memory:/") {
+            stripped
+        } else {
+            &path[1..]
+        }
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALMemoryStorage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let relative_path = self.extract_relative_path(path);
+        Ok(self.op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let relative_path = self.extract_relative_path(path);
+        let meta = self.op.stat(relative_path).await?;
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let relative_path = self.extract_relative_path(path);
+        Ok(self.op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let relative_path = self.extract_relative_path(path);
+        Ok(Box::new(self.op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let relative_path = self.extract_relative_path(path);
+        Ok(Box::new(self.op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let relative_path = self.extract_relative_path(path);
+        Ok(self.op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let relative_path = self.extract_relative_path(path);
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(self.op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for OpenDAL Memory storage
+#[derive(Debug)]
+pub struct OpenDALMemoryStorageBuilder;
 
-pub(crate) fn memory_config_build() -> Result<Operator> {
-    Ok(Operator::from_config(MemoryConfig::default())?.finish())
+impl StorageBuilder for OpenDALMemoryStorageBuilder {
+    fn build(
+        &self,
+        _props: HashMap<String, String>,
+        _extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        let op = Operator::from_config(MemoryConfig::default())?.finish();
+        Ok(Arc::new(OpenDALMemoryStorage { op }))
+    }
 }
diff --git a/crates/iceberg/src/io/storage_oss.rs b/crates/iceberg/src/io/storage_oss.rs
index 8bfffc6ca8..c070edef01 100644
--- a/crates/iceberg/src/io/storage_oss.rs
+++ b/crates/iceberg/src/io/storage_oss.rs
@@ -16,11 +16,17 @@
 // under the License.
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
+use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::services::OssConfig;
 use opendal::{Configurator, Operator};
 use url::Url;
 
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, Storage, StorageBuilder,
+};
 use crate::{Error, ErrorKind, Result};
 
 /// Required configuration arguments for creating an Aliyun OSS Operator with OpenDAL:
@@ -64,3 +70,104 @@ pub(crate) fn oss_config_build(cfg: &OssConfig, path: &str) -> Result<Operator>
 
     Ok(Operator::new(builder)?.finish())
 }
+
+/// OSS storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALOssStorage {
+    config: Arc<OssConfig>,
+}
+
+impl OpenDALOssStorage {
+    /// Creates operator from path.
+    fn create_operator<'a>(&self, path: &'a str) -> Result<(Operator, &'a str)> {
+        let op = oss_config_build(&self.config, path)?;
+        let prefix = format!("oss://{}/", op.info().name());
+
+        if path.starts_with(&prefix) {
+            let op = op.layer(opendal::layers::RetryLayer::new());
+            Ok((op, &path[prefix.len()..]))
+        } else {
+            Err(Error::new(
+                ErrorKind::DataInvalid,
+                format!("Invalid oss url: {}, should start with {}", path, prefix),
+            ))
+        }
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALOssStorage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let meta = op.stat(relative_path).await?;
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for OpenDAL OSS storage
+#[derive(Debug)]
+pub struct OpenDALOssStorageBuilder;
+
+impl StorageBuilder for OpenDALOssStorageBuilder {
+    fn build(
+        &self,
+        props: HashMap<String, String>,
+        _extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        let cfg = oss_config_parse(props)?;
+        Ok(Arc::new(OpenDALOssStorage {
+            config: Arc::new(cfg),
+        }))
+    }
+}
diff --git a/crates/iceberg/src/io/storage_s3.rs b/crates/iceberg/src/io/storage_s3.rs
index f2408331c5..cc8d84ca77 100644
--- a/crates/iceberg/src/io/storage_s3.rs
+++ b/crates/iceberg/src/io/storage_s3.rs
@@ -19,13 +19,17 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use async_trait::async_trait;
+use bytes::Bytes;
 use opendal::services::S3Config;
 use opendal::{Configurator, Operator};
 pub use reqsign::{AwsCredential, AwsCredentialLoad};
 use reqwest::Client;
 use url::Url;
 
-use crate::io::is_truthy;
+use crate::io::{
+    Extensions, FileMetadata, FileRead, FileWrite, InputFile, OutputFile, STORAGE_LOCATION_SCHEME,
+    Storage, StorageBuilder, is_truthy,
+};
 use crate::{Error, ErrorKind, Result};
 
 /// Following are arguments for [s3 file io](https://py.iceberg.apache.org/configuration/#s3).
@@ -214,3 +218,138 @@ impl AwsCredentialLoad for CustomAwsCredentialLoader {
         self.0.load_credential(client).await
     }
 }
+
+/// S3 storage implementation using OpenDAL
+#[derive(Debug, Clone)]
+pub struct OpenDALS3Storage {
+    /// s3 storage could have `s3://` and `s3a://`.
+    /// Storing the scheme string here to return the correct path.
+    configured_scheme: String,
+    config: Arc<S3Config>,
+    customized_credential_load: Option<CustomAwsCredentialLoader>,
+}
+
+impl OpenDALS3Storage {
+    /// Creates operator from path.
+    ///
+    /// # Arguments
+    ///
+    /// * path: It should be *absolute* path starting with scheme string used to construct [`FileIO`].
+    ///
+    /// # Returns
+    ///
+    /// The return value consists of two parts:
+    ///
+    /// * An [`opendal::Operator`] instance used to operate on file.
+    /// * Relative path to the root uri of [`opendal::Operator`].
+    fn create_operator<'a>(&self, path: &'a str) -> Result<(Operator, &'a str)> {
+        let op = s3_config_build(&self.config, &self.customized_credential_load, path)?;
+        let op_info = op.info();
+
+        // Check prefix of s3 path.
+        let prefix = format!("{}://{}/", self.configured_scheme, op_info.name());
+        if path.starts_with(&prefix) {
+            // Add retry layer for transient errors
+            let op = op.layer(opendal::layers::RetryLayer::new());
+            Ok((op, &path[prefix.len()..]))
+        } else {
+            Err(Error::new(
+                ErrorKind::DataInvalid,
+                format!("Invalid s3 url: {}, should start with {}", path, prefix),
+            ))
+        }
+    }
+}
+
+#[async_trait]
+impl Storage for OpenDALS3Storage {
+    async fn exists(&self, path: &str) -> Result<bool> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.exists(relative_path).await?)
+    }
+
+    async fn metadata(&self, path: &str) -> Result<FileMetadata> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let meta = op.stat(relative_path).await?;
+
+        Ok(FileMetadata {
+            size: meta.content_length(),
+        })
+    }
+
+    async fn read(&self, path: &str) -> Result<Bytes> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.read(relative_path).await?.to_bytes())
+    }
+
+    async fn reader(&self, path: &str) -> Result<Box<dyn FileRead>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.reader(relative_path).await?))
+    }
+
+    async fn write(&self, path: &str, bs: Bytes) -> Result<()> {
+        let mut writer = self.writer(path).await?;
+        writer.write(bs).await?;
+        writer.close().await
+    }
+
+    async fn writer(&self, path: &str) -> Result<Box<dyn FileWrite>> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(Box::new(op.writer(relative_path).await?))
+    }
+
+    async fn delete(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        Ok(op.delete(relative_path).await?)
+    }
+
+    async fn remove_dir_all(&self, path: &str) -> Result<()> {
+        let (op, relative_path) = self.create_operator(path)?;
+        let path = if relative_path.ends_with('/') {
+            relative_path.to_string()
+        } else {
+            format!("{relative_path}/")
+        };
+        Ok(op.remove_all(&path).await?)
+    }
+
+    fn new_input(&self, path: &str) -> Result<InputFile> {
+        Ok(InputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+
+    fn new_output(&self, path: &str) -> Result<OutputFile> {
+        Ok(OutputFile::new(Arc::new(self.clone()), path.to_string()))
+    }
+}
+
+/// Builder for S3 storage
+#[derive(Debug)]
+pub struct OpenDALS3StorageBuilder;
+
+impl StorageBuilder for OpenDALS3StorageBuilder {
+    fn build(
+        &self,
+        props: HashMap<String, String>,
+        extensions: Extensions,
+    ) -> Result<Arc<dyn Storage>> {
+        // Get the scheme string from the props or use "s3" as default
+        let scheme_str = props
+            .get(STORAGE_LOCATION_SCHEME)
+            .cloned()
+            .unwrap_or_else(|| "s3".to_string());
+
+        // Parse S3 config from props
+        let config = s3_config_parse(props)?;
+
+        // Get customized credential loader from extensions if available
+        let customized_credential_load = extensions
+            .get::<CustomAwsCredentialLoader>()
+            .map(Arc::unwrap_or_clone);
+
+        Ok(Arc::new(OpenDALS3Storage {
+            configured_scheme: scheme_str,
+            config: Arc::new(config),
+            customized_credential_load,
+        }))
+    }
+}
diff --git a/crates/iceberg/src/puffin/metadata.rs b/crates/iceberg/src/puffin/metadata.rs
index 6039c7f820..2686db06d6 100644
--- a/crates/iceberg/src/puffin/metadata.rs
+++ b/crates/iceberg/src/puffin/metadata.rs
@@ -288,10 +288,13 @@ impl FileMetadata {
 
         let input_file_length = input_file.metadata().await?.size;
         let footer_payload_length =
-            FileMetadata::read_footer_payload_length(&file_read, input_file_length).await?;
-        let footer_bytes =
-            FileMetadata::read_footer_bytes(&file_read, input_file_length, footer_payload_length)
-                .await?;
+            FileMetadata::read_footer_payload_length(file_read.as_ref(), input_file_length).await?;
+        let footer_bytes = FileMetadata::read_footer_bytes(
+            file_read.as_ref(),
+            input_file_length,
+            footer_payload_length,
+        )
+        .await?;
 
         let magic_length = FileMetadata::MAGIC_LENGTH as usize;
         // check first four bytes of footer
diff --git a/crates/iceberg/src/puffin/reader.rs b/crates/iceberg/src/puffin/reader.rs
index dce53d93f0..8941d4a8fc 100644
--- a/crates/iceberg/src/puffin/reader.rs
+++ b/crates/iceberg/src/puffin/reader.rs
@@ -18,7 +18,7 @@
 use tokio::sync::OnceCell;
 
 use crate::Result;
-use crate::io::{FileRead, InputFile};
+use crate::io::InputFile;
 use crate::puffin::blob::Blob;
 use crate::puffin::metadata::{BlobMetadata, FileMetadata};