diff --git a/test-files/subdir/foo.txt b/test-files/subdir/foo.txt
new file mode 100644
index 00000000..ab0826d5
--- /dev/null
+++ b/test-files/subdir/foo.txt
@@ -0,0 +1 @@
+Hi from foo.txt
diff --git a/tower-http/Cargo.toml b/tower-http/Cargo.toml
index d4e8fa75..003a01af 100644
--- a/tower-http/Cargo.toml
+++ b/tower-http/Cargo.toml
@@ -50,6 +50,7 @@ tower = { version = "0.4.10", features = ["buffer", "util", "retry", "make", "ti
 tracing-subscriber = "0.3"
 uuid = { version = "1.0", features = ["v4"] }
 serde_json = "1.0"
+rust-embed = "6.4"
 
 [features]
 default = []
diff --git a/tower-http/src/services/fs/backend.rs b/tower-http/src/services/fs/backend.rs
new file mode 100644
index 00000000..947cb8f8
--- /dev/null
+++ b/tower-http/src/services/fs/backend.rs
@@ -0,0 +1,98 @@
+use futures_util::future::BoxFuture;
+use std::{future::Future, io, path::Path, time::SystemTime};
+use tokio::io::{AsyncRead, AsyncSeek};
+
+// TODO(david): try and rewrite this using async-trait to see if that matters much
+// currently this requires GATs which is maybe pushing tower-http's MSRV a bit?
+//
+// async-trait is unfortunate because it requires syn+quote and requiring allocations
+// futures is unfortunate if the data is in the binary, as for rust-embed
+
+// TODO(david): implement a backend using rust-embed to prove that its possible
+
+pub trait Backend: Clone + Send + Sync + 'static {
+    type File: File<Metadata = Self::Metadata>;
+    type Metadata: Metadata;
+
+    type OpenFuture: Future<Output = io::Result<Self::File>> + Send;
+    type MetadataFuture: Future<Output = io::Result<Self::Metadata>> + Send;
+
+    fn open<A>(&self, path: A) -> Self::OpenFuture
+    where
+        A: AsRef<Path>;
+
+    fn metadata<A>(&self, path: A) -> Self::MetadataFuture
+    where
+        A: AsRef<Path>;
+}
+
+pub trait Metadata: Send + 'static {
+    fn is_dir(&self) -> bool;
+
+    fn modified(&self) -> io::Result<SystemTime>;
+
+    fn len(&self) -> u64;
+}
+
+pub trait File: AsyncRead + AsyncSeek + Unpin + Send + Sync {
+    type Metadata: Metadata;
+    type MetadataFuture<'a>: Future<Output = io::Result<Self::Metadata>> + Send
+    where
+        Self: 'a;
+
+    fn metadata(&self) -> Self::MetadataFuture<'_>;
+}
+
+#[derive(Default, Debug, Clone)]
+#[non_exhaustive]
+pub struct TokioBackend;
+
+impl Backend for TokioBackend {
+    type File = tokio::fs::File;
+    type Metadata = std::fs::Metadata;
+
+    type OpenFuture = BoxFuture<'static, io::Result<Self::File>>;
+    type MetadataFuture = BoxFuture<'static, io::Result<Self::Metadata>>;
+
+    fn open<A>(&self, path: A) -> Self::OpenFuture
+    where
+        A: AsRef<Path>,
+    {
+        let path = path.as_ref().to_owned();
+        Box::pin(tokio::fs::File::open(path))
+    }
+
+    fn metadata<A>(&self, path: A) -> Self::MetadataFuture
+    where
+        A: AsRef<Path>,
+    {
+        let path = path.as_ref().to_owned();
+        Box::pin(tokio::fs::metadata(path))
+    }
+}
+
+impl File for tokio::fs::File {
+    type Metadata = std::fs::Metadata;
+    type MetadataFuture<'a> = BoxFuture<'a, io::Result<Self::Metadata>>;
+
+    fn metadata(&self) -> Self::MetadataFuture<'_> {
+        Box::pin(self.metadata())
+    }
+}
+
+impl Metadata for std::fs::Metadata {
+    #[inline]
+    fn is_dir(&self) -> bool {
+        self.is_dir()
+    }
+
+    #[inline]
+    fn modified(&self) -> io::Result<SystemTime> {
+        self.modified()
+    }
+
+    #[inline]
+    fn len(&self) -> u64 {
+        self.len()
+    }
+}
diff --git a/tower-http/src/services/fs/mod.rs b/tower-http/src/services/fs/mod.rs
index ce6ef463..c5c26894 100644
--- a/tower-http/src/services/fs/mod.rs
+++ b/tower-http/src/services/fs/mod.rs
@@ -13,10 +13,12 @@ use std::{
 use tokio::io::{AsyncRead, AsyncReadExt, Take};
 use tokio_util::io::ReaderStream;
 
+mod backend;
 mod serve_dir;
 mod serve_file;
 
 pub use self::{
+    backend::{Backend, File, Metadata},
     serve_dir::{
         future::ResponseFuture as ServeFileSystemResponseFuture,
         DefaultServeDirFallback,
diff --git a/tower-http/src/services/fs/serve_dir/future.rs b/tower-http/src/services/fs/serve_dir/future.rs
index 36b35039..78fa5def 100644
--- a/tower-http/src/services/fs/serve_dir/future.rs
+++ b/tower-http/src/services/fs/serve_dir/future.rs
@@ -1,8 +1,11 @@
 use super::{
     open_file::{FileOpened, FileRequestExtent, OpenFileOutput},
-    DefaultServeDirFallback, ResponseBody,
+    ResponseBody,
+};
+use crate::{
+    services::fs::{AsyncReadBody, Backend, Metadata as _},
+    BoxError,
 };
-use crate::{services::fs::AsyncReadBody, BoxError};
 use bytes::Bytes;
 use futures_util::{
     future::{BoxFuture, FutureExt, TryFutureExt},
@@ -25,15 +28,15 @@ use tower_service::Service;
 
 pin_project! {
     /// Response future of [`ServeDir::try_call`].
-    pub struct ResponseFuture<ReqBody, F = DefaultServeDirFallback> {
+    pub struct ResponseFuture<ReqBody, F, B: Backend> {
         #[pin]
-        pub(super) inner: ResponseFutureInner<ReqBody, F>,
+        pub(super) inner: ResponseFutureInner<ReqBody, F, B>,
     }
 }
 
-impl<ReqBody, F> ResponseFuture<ReqBody, F> {
+impl<ReqBody, F, B: Backend> ResponseFuture<ReqBody, F, B> {
     pub(super) fn open_file_future(
-        future: BoxFuture<'static, io::Result<OpenFileOutput>>,
+        future: BoxFuture<'static, io::Result<OpenFileOutput<B>>>,
         fallback_and_request: Option<(F, Request<ReqBody>)>,
     ) -> Self {
         Self {
@@ -61,10 +64,10 @@ impl<ReqBody, F> ResponseFuture<ReqBody, F> {
 
 pin_project! {
     #[project = ResponseFutureInnerProj]
-    pub(super) enum ResponseFutureInner<ReqBody, F> {
+    pub(super) enum ResponseFutureInner<ReqBody, F, B: Backend> {
         OpenFileFuture {
             #[pin]
-            future: BoxFuture<'static, io::Result<OpenFileOutput>>,
+            future: BoxFuture<'static, io::Result<OpenFileOutput<B>>>,
             fallback_and_request: Option<(F, Request<ReqBody>)>,
         },
         FallbackFuture {
@@ -77,12 +80,13 @@ pin_project! {
     }
 }
 
-impl<F, ReqBody, ResBody> Future for ResponseFuture<ReqBody, F>
+impl<F, B, ReqBody, ResBody> Future for ResponseFuture<ReqBody, F, B>
 where
     F: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible> + Clone,
     F::Future: Send + 'static,
     ResBody: http_body::Body<Data = Bytes> + Send + 'static,
     ResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    B: Backend,
 {
     type Output = io::Result<Response<ResponseBody>>;
 
@@ -176,15 +180,16 @@ fn not_found() -> Response<ResponseBody> {
     response_with_status(StatusCode::NOT_FOUND)
 }
 
-pub(super) fn call_fallback<F, B, FResBody>(
+pub(super) fn call_fallback<F, ReqBody, FResBody, B>(
     fallback: &mut F,
-    req: Request<B>,
-) -> ResponseFutureInner<B, F>
+    req: Request<ReqBody>,
+) -> ResponseFutureInner<ReqBody, F, B>
 where
-    F: Service<Request<B>, Response = Response<FResBody>, Error = Infallible> + Clone,
+    F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
     F::Future: Send + 'static,
     FResBody: http_body::Body<Data = Bytes> + Send + 'static,
     FResBody::Error: Into<BoxError>,
+    B: Backend,
 {
     let future = fallback
         .call(req)
@@ -204,7 +209,10 @@ where
     ResponseFutureInner::FallbackFuture { future }
 }
 
-fn build_response(output: FileOpened) -> Response<ResponseBody> {
+fn build_response<B>(output: FileOpened<B>) -> Response<ResponseBody>
+where
+    B: Backend,
+{
     let (maybe_file, size) = match output.extent {
         FileRequestExtent::Full(file, meta) => (Some(file), meta.len()),
         FileRequestExtent::Head(meta) => (None, meta.len()),
diff --git a/tower-http/src/services/fs/serve_dir/mod.rs b/tower-http/src/services/fs/serve_dir/mod.rs
index 6c869d19..950609a1 100644
--- a/tower-http/src/services/fs/serve_dir/mod.rs
+++ b/tower-http/src/services/fs/serve_dir/mod.rs
@@ -8,14 +8,19 @@ use futures_util::FutureExt;
 use http::{header, HeaderValue, Method, Request, Response, StatusCode};
 use http_body::{combinators::UnsyncBoxBody, Body, Empty};
 use percent_encoding::percent_decode;
+use pin_project_lite::pin_project;
 use std::{
     convert::Infallible,
+    future::Future,
     io,
+    marker::PhantomData,
     path::{Component, Path, PathBuf},
     task::{Context, Poll},
 };
 use tower_service::Service;
 
+use super::{backend::TokioBackend, Backend};
+
 pub(crate) mod future;
 mod headers;
 mod open_file;
@@ -56,7 +61,7 @@ const DEFAULT_CAPACITY: usize = 65536;
 /// # };
 /// ```
 #[derive(Clone, Debug)]
-pub struct ServeDir<F = DefaultServeDirFallback> {
+pub struct ServeDir<F = DefaultServeDirFallback<TokioBackend>, B = TokioBackend> {
     base: PathBuf,
     buf_chunk_size: usize,
     precompressed_variants: Option<PrecompressedVariants>,
@@ -65,9 +70,10 @@ pub struct ServeDir<F = DefaultServeDirFallback> {
     variant: ServeVariant,
     fallback: Option<F>,
     call_fallback_on_method_not_allowed: bool,
+    backend: B,
 }
 
-impl ServeDir<DefaultServeDirFallback> {
+impl ServeDir<DefaultServeDirFallback<TokioBackend>, TokioBackend> {
     /// Create a new [`ServeDir`].
     pub fn new<P>(path: P) -> Self
     where
@@ -85,6 +91,7 @@ impl ServeDir<DefaultServeDirFallback> {
             },
             fallback: None,
             call_fallback_on_method_not_allowed: false,
+            backend: TokioBackend,
         }
     }
 
@@ -99,11 +106,12 @@ impl ServeDir<DefaultServeDirFallback> {
             variant: ServeVariant::SingleFile { mime },
             fallback: None,
             call_fallback_on_method_not_allowed: false,
+            backend: TokioBackend,
         }
     }
 }
 
-impl<F> ServeDir<F> {
+impl<F, B> ServeDir<F, B> {
     /// If the requested path is a directory append `index.html`.
     ///
     /// This is useful for static sites.
@@ -207,7 +215,7 @@ impl<F> ServeDir<F> {
     ///     .expect("server error");
     /// # };
     /// ```
-    pub fn fallback<F2>(self, new_fallback: F2) -> ServeDir<F2> {
+    pub fn fallback<F2>(self, new_fallback: F2) -> ServeDir<F2, B> {
         ServeDir {
             base: self.base,
             buf_chunk_size: self.buf_chunk_size,
@@ -215,6 +223,7 @@ impl<F> ServeDir<F> {
             variant: self.variant,
             fallback: Some(new_fallback),
             call_fallback_on_method_not_allowed: self.call_fallback_on_method_not_allowed,
+            backend: self.backend,
         }
     }
 
@@ -244,7 +253,7 @@ impl<F> ServeDir<F> {
     /// ```
     ///
     /// Setups like this are often found in single page applications.
-    pub fn not_found_service<F2>(self, new_fallback: F2) -> ServeDir<SetStatus<F2>> {
+    pub fn not_found_service<F2>(self, new_fallback: F2) -> ServeDir<SetStatus<F2>, B> {
         self.fallback(SetStatus::new(new_fallback, StatusCode::NOT_FOUND))
     }
 
@@ -256,6 +265,22 @@ impl<F> ServeDir<F> {
         self
     }
 
+    /// TODO(david): docs
+    pub fn backend<B2>(self, new_backend: B2) -> ServeDir<F, B2>
+    where
+        B2: Backend,
+    {
+        ServeDir {
+            base: self.base,
+            buf_chunk_size: self.buf_chunk_size,
+            precompressed_variants: self.precompressed_variants,
+            variant: self.variant,
+            fallback: self.fallback,
+            call_fallback_on_method_not_allowed: self.call_fallback_on_method_not_allowed,
+            backend: new_backend,
+        }
+    }
+
     /// Call the service and get a future that contains any `std::io::Error` that might have
     /// happened.
     ///
@@ -322,12 +347,13 @@ impl<F> ServeDir<F> {
     pub fn try_call<ReqBody, FResBody>(
         &mut self,
         req: Request<ReqBody>,
-    ) -> ResponseFuture<ReqBody, F>
+    ) -> ResponseFuture<ReqBody, F, B>
     where
         F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
         F::Future: Send + 'static,
         FResBody: http_body::Body<Data = Bytes> + Send + 'static,
         FResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+        B: Backend,
     {
         if req.method() != Method::GET && req.method() != Method::HEAD {
             if self.call_fallback_on_method_not_allowed {
@@ -395,22 +421,24 @@ impl<F> ServeDir<F> {
             negotiated_encodings,
             range_header,
             buf_chunk_size,
+            self.backend.clone(),
         ));
 
         ResponseFuture::open_file_future(open_file_future, fallback_and_request)
     }
 }
 
-impl<ReqBody, F, FResBody> Service<Request<ReqBody>> for ServeDir<F>
+impl<ReqBody, B, F, FResBody> Service<Request<ReqBody>> for ServeDir<F, B>
 where
     F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
     F::Future: Send + 'static,
     FResBody: http_body::Body<Data = Bytes> + Send + 'static,
     FResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    B: Backend,
 {
     type Response = Response<ResponseBody>;
     type Error = Infallible;
-    type Future = InfallibleResponseFuture<ReqBody, F>;
+    type Future = InfallibleResponseFuture<ReqBody, F, B>;
 
     #[inline]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -438,17 +466,37 @@ where
                 Ok(response)
             } as _);
 
-        InfallibleResponseFuture::new(future)
+        InfallibleResponseFuture { future }
     }
 }
 
-opaque_future! {
+pin_project! {
     /// Response future of [`ServeDir`].
-    pub type InfallibleResponseFuture<ReqBody, F> =
-        futures_util::future::Map<
-            ResponseFuture<ReqBody, F>,
+    pub struct InfallibleResponseFuture<ReqBody, F, B: Backend> {
+        #[pin]
+        pub(crate) future: futures_util::future::Map<
+            ResponseFuture<ReqBody, F, B>,
             fn(Result<Response<ResponseBody>, io::Error>) -> Result<Response<ResponseBody>, Infallible>,
-        >;
+        >,
+    }
+}
+
+impl<ReqBody, F, FResBody, B: Backend> Future for InfallibleResponseFuture<ReqBody, F, B>
+where
+    F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
+    F::Future: Send + 'static,
+    FResBody: http_body::Body<Data = Bytes> + Send + 'static,
+    FResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    B: Backend,
+{
+    type Output = <futures_util::future::Map<
+        ResponseFuture<ReqBody, F, B>,
+        fn(Result<Response<ResponseBody>, io::Error>) -> Result<Response<ResponseBody>, Infallible>,
+    > as Future>::Output;
+
+    fn poll(self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.project().future.poll(cx)
+    }
 }
 
 // Allow the ServeDir service to be used in the ServeFile service
@@ -507,16 +555,23 @@ opaque_body! {
 }
 
 /// The default fallback service used with [`ServeDir`].
-#[derive(Debug, Clone, Copy)]
-pub struct DefaultServeDirFallback(Infallible);
+#[derive(Debug, Copy)]
+pub struct DefaultServeDirFallback<B: Backend>(Infallible, PhantomData<fn() -> B::Metadata>);
+
+impl<B: Backend> Clone for DefaultServeDirFallback<B> {
+    fn clone(&self) -> Self {
+        Self(self.0, self.1)
+    }
+}
 
-impl<ReqBody> Service<Request<ReqBody>> for DefaultServeDirFallback
+impl<ReqBody, B> Service<Request<ReqBody>> for DefaultServeDirFallback<B>
 where
     ReqBody: Send + 'static,
+    B: Backend,
 {
     type Response = Response<ResponseBody>;
     type Error = Infallible;
-    type Future = InfallibleResponseFuture<ReqBody, Self>;
+    type Future = InfallibleResponseFuture<ReqBody, Self, B>;
 
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         match self.0 {}
diff --git a/tower-http/src/services/fs/serve_dir/open_file.rs b/tower-http/src/services/fs/serve_dir/open_file.rs
index a24aa088..71790918 100644
--- a/tower-http/src/services/fs/serve_dir/open_file.rs
+++ b/tower-http/src/services/fs/serve_dir/open_file.rs
@@ -2,30 +2,32 @@ use super::{
     headers::{IfModifiedSince, IfUnmodifiedSince, LastModified},
     ServeVariant,
 };
-use crate::content_encoding::{Encoding, QValue};
+use crate::{
+    content_encoding::{Encoding, QValue},
+    services::fs::{backend::File, Backend, Metadata as _},
+};
 use bytes::Bytes;
 use http::{header, HeaderValue, Method, Request, Uri};
 use http_body::Empty;
 use http_range_header::RangeUnsatisfiableError;
 use std::{
     ffi::OsStr,
-    fs::Metadata,
     io::{self, SeekFrom},
     ops::RangeInclusive,
     path::{Path, PathBuf},
 };
-use tokio::{fs::File, io::AsyncSeekExt};
+use tokio::io::AsyncSeekExt;
 
-pub(super) enum OpenFileOutput {
-    FileOpened(Box<FileOpened>),
+pub(super) enum OpenFileOutput<B: Backend> {
+    FileOpened(Box<FileOpened<B>>),
     Redirect { location: HeaderValue },
     FileNotFound,
     PreconditionFailed,
     NotModified,
 }
 
-pub(super) struct FileOpened {
-    pub(super) extent: FileRequestExtent,
+pub(super) struct FileOpened<B: Backend> {
+    pub(super) extent: FileRequestExtent<B>,
     pub(super) chunk_size: usize,
     pub(super) mime_header_value: HeaderValue,
     pub(super) maybe_encoding: Option<Encoding>,
@@ -33,19 +35,23 @@ pub(super) struct FileOpened {
     pub(super) last_modified: Option<LastModified>,
 }
 
-pub(super) enum FileRequestExtent {
-    Full(File, Metadata),
-    Head(Metadata),
+pub(super) enum FileRequestExtent<B: Backend> {
+    Full(B::File, B::Metadata),
+    Head(B::Metadata),
 }
 
-pub(super) async fn open_file(
+pub(super) async fn open_file<B>(
     variant: ServeVariant,
     mut path_to_file: PathBuf,
     req: Request<Empty<Bytes>>,
     negotiated_encodings: Vec<(Encoding, QValue)>,
     range_header: Option<String>,
     buf_chunk_size: usize,
-) -> io::Result<OpenFileOutput> {
+    backend: B,
+) -> io::Result<OpenFileOutput<B>>
+where
+    B: Backend,
+{
     let if_unmodified_since = req
         .headers()
         .get(header::IF_UNMODIFIED_SINCE)
@@ -67,6 +73,7 @@ pub(super) async fn open_file(
                 &mut path_to_file,
                 req.uri(),
                 append_index_html_on_directories,
+                &backend,
             )
             .await
             {
@@ -86,7 +93,7 @@ pub(super) async fn open_file(
 
     if req.method() == Method::HEAD {
         let (meta, maybe_encoding) =
-            file_metadata_with_fallback(path_to_file, negotiated_encodings).await?;
+            file_metadata_with_fallback(path_to_file, negotiated_encodings, &backend).await?;
 
         let last_modified = meta.modified().ok().map(LastModified::from);
         if let Some(output) = check_modified_headers(
@@ -109,7 +116,7 @@ pub(super) async fn open_file(
         })))
     } else {
         let (mut file, maybe_encoding) =
-            open_file_with_fallback(path_to_file, negotiated_encodings).await?;
+            open_file_with_fallback(path_to_file, negotiated_encodings, &backend).await?;
         let meta = file.metadata().await?;
         let last_modified = meta.modified().ok().map(LastModified::from);
         if let Some(output) = check_modified_headers(
@@ -140,11 +147,11 @@ pub(super) async fn open_file(
     }
 }
 
-fn check_modified_headers(
+fn check_modified_headers<B: Backend>(
     modified: Option<&LastModified>,
     if_unmodified_since: Option<IfUnmodifiedSince>,
     if_modified_since: Option<IfModifiedSince>,
-) -> Option<OpenFileOutput> {
+) -> Option<OpenFileOutput<B>> {
     if let Some(since) = if_unmodified_since {
         let precondition = modified
             .as_ref()
@@ -199,14 +206,15 @@ fn preferred_encoding(
 // Attempts to open the file with any of the possible negotiated_encodings in the
 // preferred order. If none of the negotiated_encodings have a corresponding precompressed
 // file the uncompressed file is used as a fallback.
-async fn open_file_with_fallback(
+async fn open_file_with_fallback<B: Backend>(
     mut path: PathBuf,
     mut negotiated_encoding: Vec<(Encoding, QValue)>,
-) -> io::Result<(File, Option<Encoding>)> {
+    backend: &B,
+) -> io::Result<(B::File, Option<Encoding>)> {
     let (file, encoding) = loop {
         // Get the preferred encoding among the negotiated ones.
         let encoding = preferred_encoding(&mut path, &negotiated_encoding);
-        match (File::open(&path).await, encoding) {
+        match (backend.open(&path).await, encoding) {
             (Ok(file), maybe_encoding) => break (file, maybe_encoding),
             (Err(err), Some(encoding)) if err.kind() == io::ErrorKind::NotFound => {
                 // Remove the extension corresponding to a precompressed file (.gz, .br, .zz)
@@ -226,14 +234,18 @@ async fn open_file_with_fallback(
 // Attempts to get the file metadata with any of the possible negotiated_encodings in the
 // preferred order. If none of the negotiated_encodings have a corresponding precompressed
 // file the uncompressed file is used as a fallback.
-async fn file_metadata_with_fallback(
+async fn file_metadata_with_fallback<B>(
     mut path: PathBuf,
     mut negotiated_encoding: Vec<(Encoding, QValue)>,
-) -> io::Result<(Metadata, Option<Encoding>)> {
+    backend: &B,
+) -> io::Result<(B::Metadata, Option<Encoding>)>
+where
+    B: Backend,
+{
     let (file, encoding) = loop {
         // Get the preferred encoding among the negotiated ones.
         let encoding = preferred_encoding(&mut path, &negotiated_encoding);
-        match (tokio::fs::metadata(&path).await, encoding) {
+        match (backend.metadata(&path).await, encoding) {
             (Ok(file), maybe_encoding) => break (file, maybe_encoding),
             (Err(err), Some(encoding)) if err.kind() == io::ErrorKind::NotFound => {
                 // Remove the extension corresponding to a precompressed file (.gz, .br, .zz)
@@ -250,20 +262,24 @@ async fn file_metadata_with_fallback(
     Ok((file, encoding))
 }
 
-async fn maybe_redirect_or_append_path(
+async fn maybe_redirect_or_append_path<B>(
     path_to_file: &mut PathBuf,
     uri: &Uri,
     append_index_html_on_directories: bool,
-) -> Option<OpenFileOutput> {
+    backend: &B,
+) -> Option<OpenFileOutput<B>>
+where
+    B: Backend,
+{
     if !uri.path().ends_with('/') {
-        if is_dir(path_to_file).await {
+        if is_dir(path_to_file, backend).await {
             let location =
                 HeaderValue::from_str(&append_slash_on_path(uri.clone()).to_string()).unwrap();
             Some(OpenFileOutput::Redirect { location })
         } else {
             None
         }
-    } else if is_dir(path_to_file).await {
+    } else if is_dir(path_to_file, backend).await {
         if append_index_html_on_directories {
             path_to_file.push("index.html");
             None
@@ -285,8 +301,12 @@ fn try_parse_range(
     })
 }
 
-async fn is_dir(path_to_file: &Path) -> bool {
-    tokio::fs::metadata(path_to_file)
+async fn is_dir<B>(path_to_file: &Path, backend: &B) -> bool
+where
+    B: Backend,
+{
+    backend
+        .metadata(path_to_file)
         .await
         .map_or(false, |meta_data| meta_data.is_dir())
 }
diff --git a/tower-http/src/services/fs/serve_dir/tests.rs b/tower-http/src/services/fs/serve_dir/tests.rs
index acc16ec4..3e1e55d6 100644
--- a/tower-http/src/services/fs/serve_dir/tests.rs
+++ b/tower-http/src/services/fs/serve_dir/tests.rs
@@ -1,3 +1,4 @@
+use crate::services::fs::{self, Backend};
 use crate::services::{ServeDir, ServeFile};
 use brotli::BrotliDecompress;
 use bytes::Bytes;
@@ -7,8 +8,16 @@ use http::{header, Method, Response};
 use http::{Request, StatusCode};
 use http_body::Body as HttpBody;
 use hyper::Body;
+use std::borrow::Cow;
 use std::convert::Infallible;
-use std::io::{self, Read};
+use std::future::{ready, Ready};
+use std::io::{self, Cursor, Read};
+use std::path::Path;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use std::time::SystemTime;
+use tokio::io::{AsyncRead, AsyncSeek, ReadBuf};
 use tower::{service_fn, ServiceExt};
 
 #[tokio::test]
@@ -711,3 +720,146 @@ async fn calls_fallback_on_invalid_paths() {
 
     assert_eq!(res.headers()["from-fallback"], "1");
 }
+
+#[tokio::test]
+async fn custom_backend() {
+    #[derive(Clone, rust_embed::RustEmbed)]
+    #[folder = "../test-files"]
+    struct RustEmbedFiles;
+
+    impl RustEmbedFiles {
+        fn get_file(&self, path: &Path) -> io::Result<rust_embed::EmbeddedFile> {
+            // TODO(david): we have to handle directories here which rust-embed does not
+
+            for file in Self::iter() {
+                dbg!(&file);
+            }
+
+            if path == Path::new("./.") {
+                todo!("bingo");
+            }
+
+            for filename in Self::iter() {
+                dbg!(filename);
+            }
+
+            if let Some(file) = Self::get(path.to_str().unwrap()) {
+                Ok(file)
+            } else {
+                Err(io::Error::new(
+                    io::ErrorKind::NotFound,
+                    format!("{} not found", path.display()),
+                ))
+            }
+        }
+    }
+
+    impl Backend for RustEmbedFiles {
+        type File = RustEmbedFile;
+        type Metadata = RustEmbedMetadata;
+
+        type OpenFuture = Ready<io::Result<Self::File>>;
+        type MetadataFuture = Ready<io::Result<Self::Metadata>>;
+
+        fn open<A>(&self, path: A) -> Self::OpenFuture
+        where
+            A: AsRef<Path>,
+        {
+            let path = path.as_ref();
+
+            let rust_embed::EmbeddedFile { data, metadata } = match self.get_file(path) {
+                Ok(file) => file,
+                Err(err) => return ready(Err(err)),
+            };
+
+            ready(Ok(RustEmbedFile {
+                metadata: Arc::new(metadata),
+                len: data.len() as u64,
+                cursor: Cursor::new(data),
+            }))
+        }
+
+        fn metadata<A>(&self, path: A) -> Self::MetadataFuture
+        where
+            A: AsRef<Path>,
+        {
+            let rust_embed::EmbeddedFile { metadata, data } = match self.get_file(path.as_ref()) {
+                Ok(file) => file,
+                Err(err) => return ready(Err(err)),
+            };
+
+            ready(Ok(RustEmbedMetadata {
+                metadata: Arc::new(metadata),
+                len: data.len() as u64,
+            }))
+        }
+    }
+
+    struct RustEmbedFile {
+        metadata: Arc<rust_embed::Metadata>,
+        cursor: std::io::Cursor<Cow<'static, [u8]>>,
+        len: u64,
+    }
+
+    impl AsyncRead for RustEmbedFile {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.cursor).poll_read(cx, buf)
+        }
+    }
+
+    impl AsyncSeek for RustEmbedFile {
+        fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+            unimplemented!()
+        }
+
+        fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+            unimplemented!()
+        }
+    }
+
+    impl fs::File for RustEmbedFile {
+        type Metadata = RustEmbedMetadata;
+        type MetadataFuture<'a> = Ready<io::Result<Self::Metadata>>;
+
+        fn metadata(&self) -> Self::MetadataFuture<'_> {
+            ready(Ok(RustEmbedMetadata {
+                metadata: Arc::clone(&self.metadata),
+                len: self.len,
+            }))
+        }
+    }
+
+    struct RustEmbedMetadata {
+        metadata: Arc<rust_embed::Metadata>,
+        len: u64,
+    }
+
+    impl fs::Metadata for RustEmbedMetadata {
+        fn is_dir(&self) -> bool {
+            false
+        }
+
+        fn modified(&self) -> io::Result<SystemTime> {
+            todo!()
+        }
+
+        fn len(&self) -> u64 {
+            self.len
+        }
+    }
+
+    let svc = ServeDir::new(".").backend(RustEmbedFiles);
+
+    let req = Request::builder().uri("/").body(Body::empty()).unwrap();
+
+    let res = svc.oneshot(req).await.unwrap();
+
+    assert_eq!(res.status(), StatusCode::OK);
+
+    let body = body_into_text(res.into_body()).await;
+    assert_eq!(body, "<b>HTML!</b>\n");
+}
diff --git a/tower-http/src/services/fs/serve_file.rs b/tower-http/src/services/fs/serve_file.rs
index ede79936..c5f3fd3b 100644
--- a/tower-http/src/services/fs/serve_file.rs
+++ b/tower-http/src/services/fs/serve_file.rs
@@ -1,9 +1,11 @@
 //! Service that serves a file.
 
-use super::ServeDir;
-use http::{HeaderValue, Request};
+use super::{backend::TokioBackend, Backend, DefaultServeDirFallback, ServeDir};
+use bytes::Bytes;
+use http::{HeaderValue, Request, Response};
 use mime::Mime;
 use std::{
+    convert::Infallible,
     path::Path,
     task::{Context, Poll},
 };
@@ -11,10 +13,10 @@ use tower_service::Service;
 
 /// Service that serves a file.
 #[derive(Clone, Debug)]
-pub struct ServeFile(ServeDir);
+pub struct ServeFile<F = DefaultServeDirFallback<TokioBackend>, B = TokioBackend>(ServeDir<F, B>);
 
 // Note that this is just a special case of ServeDir
-impl ServeFile {
+impl ServeFile<DefaultServeDirFallback<TokioBackend>, TokioBackend> {
     /// Create a new [`ServeFile`].
     ///
     /// The `Content-Type` will be guessed from the file extension.
@@ -41,7 +43,9 @@ impl ServeFile {
         let mime = HeaderValue::from_str(mime.as_ref()).expect("mime isn't a valid header value");
         Self(ServeDir::new_single_file(path, mime))
     }
+}
 
+impl<F, B> ServeFile<F, B> {
     /// Informs the service that it should also look for a precompressed gzip
     /// version of the file.
     ///
@@ -91,28 +95,48 @@ impl ServeFile {
         Self(self.0.with_buf_chunk_size(chunk_size))
     }
 
+    /// TODO(david): docs
+    pub fn backend<B2>(self, new_backend: B2) -> ServeFile<F, B2>
+    where
+        B2: Backend,
+    {
+        ServeFile(self.0.backend(new_backend))
+    }
+}
+
+impl<F, B> ServeFile<F, B> {
     /// Call the service and get a future that contains any `std::io::Error` that might have
     /// happened.
     ///
     /// See [`ServeDir::try_call`] for more details.
-    pub fn try_call<ReqBody>(
+    pub fn try_call<ReqBody, FResBody>(
         &mut self,
         req: Request<ReqBody>,
-    ) -> super::serve_dir::future::ResponseFuture<ReqBody>
+    ) -> super::serve_dir::future::ResponseFuture<ReqBody, F, B>
     where
         ReqBody: Send + 'static,
+        F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
+        F::Future: Send + 'static,
+        FResBody: http_body::Body<Data = Bytes> + Send + 'static,
+        FResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+        B: Backend,
     {
         self.0.try_call(req)
     }
 }
 
-impl<ReqBody> Service<Request<ReqBody>> for ServeFile
+impl<ReqBody, F, B, FResBody> Service<Request<ReqBody>> for ServeFile<F, B>
 where
     ReqBody: Send + 'static,
+    F: Service<Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone,
+    F::Future: Send + 'static,
+    FResBody: http_body::Body<Data = Bytes> + Send + 'static,
+    FResBody::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    B: Backend,
 {
-    type Error = <ServeDir as Service<Request<ReqBody>>>::Error;
-    type Response = <ServeDir as Service<Request<ReqBody>>>::Response;
-    type Future = <ServeDir as Service<Request<ReqBody>>>::Future;
+    type Error = <ServeDir<F, B> as Service<Request<ReqBody>>>::Error;
+    type Response = <ServeDir<F, B> as Service<Request<ReqBody>>>::Response;
+    type Future = <ServeDir<F, B> as Service<Request<ReqBody>>>::Future;
 
     #[inline]
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {