diff --git a/Cargo.toml b/Cargo.toml
index 42fd3745..cf3e1017 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,5 +22,6 @@ tower-async = { version = "0.1" }
 tracing = "0.1"
 
 [dev-dependencies]
+anyhow = "1.0"
 tokio-test = "0.4"
 tracing-subscriber = "0.3"
diff --git a/src/transport/tcp/server/listener.rs b/src/transport/tcp/server/listener.rs
index 563f2133..4afe0d84 100644
--- a/src/transport/tcp/server/listener.rs
+++ b/src/transport/tcp/server/listener.rs
@@ -15,7 +15,7 @@ use crate::transport::{connection::Connection, graceful};
 /// Listens to incoming TCP connections and serves them with a [`tower_async::Service`].
 ///
 /// That [`tower_async::Service`] is created by a [`tower_async::Service`] for each incoming connection.
-/// 
+///
 /// [`tower_async::Service`]: https://docs.rs/tower-async/*/tower_async/trait.Service.html
 #[derive(Debug)]
 pub struct TcpListener<S, H> {
@@ -74,7 +74,7 @@ impl TryFrom<std::net::TcpListener>
 impl<H> TcpListener<private::NoState, H> {
     /// Sets a state for the [`TcpListener`],
     /// which will be passed to the [`tower_async::Service`] for each incoming connection.
-    /// 
+    ///
     /// [`tower_async::Service`]: https://docs.rs/tower-async/*/tower_async/trait.Service.html
     pub fn state<S>(self, state: S) -> TcpListener<S, H>
     where
@@ -199,7 +199,7 @@ mod private {
 
     use crate::transport::tcp::server::error::{Error, ErrorHandler, ErrorKind};
 
-    #[derive(Debug)]
+    #[derive(Debug, Clone, Copy, Default)]
     pub(super) struct NoState;
 
     #[derive(Debug, Clone, Copy, Default)]
diff --git a/src/transport/tcp/server/listener_backup.rs b/src/transport/tcp/server/listener_backup.rs
deleted file mode 100644
index 5c782e5f..00000000
--- a/src/transport/tcp/server/listener_backup.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-use std::{
-    net::{TcpListener as StdTcpListener, ToSocketAddrs},
-    time::Duration, future::Future, convert::Infallible,
-};
-
-use tokio::net::TcpListener;
-
-use crate::{transport::graceful, service::{Service, ServiceFactory}};
-
-mod marker {
-    #[derive(Debug)]
-    pub(super) struct None;
-
-    #[derive(Debug)]
-    pub(super) struct Some<T>(pub(super) T);
-}
-
-#[derive(Debug)]
-pub struct Listener<F, State> {
-    tcp: TcpListener,
-    service_factory: F,
-    shutdown_timeout: Option<Duration>,
-    graceful: graceful::GracefulService,
-    state: State,
-}
-
-#[derive(Debug)]
-pub struct Builder<I, G, S> {
-    incoming: I,
-    graceful: G,
-    state: S,
-}
-
-#[derive(Debug)]
-pub struct SocketConfig<L> {
-    listener: L,
-    ttl: Option<u32>,
-}
-
-#[derive(Debug)]
-pub struct GracefulConfig<S> {
-    shutdown: S,
-    timeout: Option<Duration>,
-}
-
-pub trait IntoTcpListener {
-    fn into_tcp_listener(self) -> Result<TcpListener, std::io::Error>;
-}
-
-impl IntoTcpListener for TcpListener {
-    fn into_tcp_listener(self) -> Result<TcpListener, std::io::Error> {
-        Ok(self)
-    }
-}
-
-impl IntoTcpListener for StdTcpListener {
-    fn into_tcp_listener(self) -> Result<TcpListener, std::io::Error> {
-        TcpListener::from_std(self)
-    }
-}
-
-impl Listener<marker::None, marker::None> {
-    pub fn bind<A: ToSocketAddrs>(addr: A) -> Builder<SocketConfig<TcpListener>, marker::None, marker::None> {
-        match Self::try_bind(addr) {
-            Ok(incoming) => incoming,
-            Err(err) => panic!("failed to bind tcp listener: {}", err),
-        }
-    }
-
-    pub fn try_bind<A: ToSocketAddrs>(
-        addr: A,
-    ) -> Result<Builder<SocketConfig<TcpListener>, marker::None, marker::None>, std::io::Error> {
-        let incoming = StdTcpListener::bind(addr)?;
-        incoming.set_nonblocking(true)?;
-        Self::build(incoming)
-    }
-
-    pub fn build(incoming: impl IntoTcpListener) -> Result<Builder<SocketConfig<TcpListener>, marker::None, marker::None>, std::io::Error> {
-        let listener = incoming.into_tcp_listener()?;
-        Ok(Builder::new(listener, marker::None, marker::None))
-    }
-}
-
-impl<G, S> Builder<SocketConfig<TcpListener>, G, S> {
-    /// Create a new `Builder` with the specified address.
-    fn new(listener: TcpListener, graceful: G, state: S) -> Self {
-        Self {
-            incoming: SocketConfig {
-                listener,
-                ttl: None,
-            },
-            graceful,
-            state,
-        }
-    }
-
-    /// Set the value of `IP_TTL` option for accepted connections.
-    ///
-    /// If `None` is specified, ttl is not explicitly set.
-    pub fn ttl(mut self, ttl: Option<u32>) -> Self {
-        self.incoming.ttl = ttl;
-        self
-    }
-}
-
-impl<I, State> Builder<I, marker::None, State> {
-    /// Upgrade the builder to one which builds
-    /// a graceful TCP listener which will shutdown once the given future resolves.
-    pub fn graceful<S: Future<Output = ()>>(
-        self,
-        shutdown: S,
-    ) -> Builder<I, GracefulConfig<S>, State> {
-        Builder {
-            incoming: self.incoming,
-            graceful: GracefulConfig {
-                shutdown,
-                timeout: None,
-            },
-            state: self.state,
-        }
-    }
-
-    /// Upgrade the builder to one which builds
-    /// a graceful TCP listener which will shutdown once the "ctrl+c" signal is received (SIGINT).
-    pub fn graceful_ctrl_c(self) -> Builder<I, GracefulConfig<impl Future<Output = ()>>, State> {
-        self.graceful(async {
-            let _ = tokio::signal::ctrl_c().await;
-        })
-    }
-}
-
-impl<I, G> Builder<I, G, marker::None> {
-    pub fn state<S>(self, state: S) -> Builder<I, G, marker::Some<S>> {
-        Builder {
-            incoming: self.incoming,
-            graceful: self.graceful,
-            state: marker::Some(state),
-        }
-    }
-}
-
-impl<I, S, State> Builder<I, GracefulConfig<S>, State> {
-    /// Set the timeout for graceful shutdown.
-    ///
-    /// If `None` is specified, the default timeout is used.
-    pub fn timeout(mut self, timeout: Option<Duration>) -> Self {
-        self.graceful.timeout = timeout;
-        self
-    }
-}
-
-impl<S, State> Builder<SocketConfig<TcpListener>, GracefulConfig<S>, State>
-where
-    S: Future + Send + 'static,
-{
-    pub async fn serve<F>(self, service_factory: F) -> Result<(), Box<dyn std::error::Error>>
-    where
-        F: ServiceFactory<State>,
-        F::Service: Service<State> + Send + 'static,
-    {
-        // create and configure the tcp listener...
-        let listener = self.incoming.listener;
-        if let Some(ttl) = self.incoming.ttl {
-            listener.set_ttl(ttl)?;
-        }
-        // listen gracefully..
-        Listener::new(
-            listener,
-            service_factory,
-            self.graceful.shutdown,
-            self.graceful.timeout,
-        )
-        .serve()
-        .await
-    }
-}
\ No newline at end of file
diff --git a/src/transport/tcp/server/mod.rs b/src/transport/tcp/server/mod.rs
index 96d37c92..c57654f9 100644
--- a/src/transport/tcp/server/mod.rs
+++ b/src/transport/tcp/server/mod.rs
@@ -3,6 +3,7 @@
 //! as the entrypoint of pretty much any Rama server.
 
 pub mod error;
+pub mod factory;
 
 mod listener;
 pub use listener::*;