diff --git a/src/login/mod.rs b/src/login/mod.rs
index e87a17d..e934112 100644
--- a/src/login/mod.rs
+++ b/src/login/mod.rs
@@ -39,7 +39,7 @@ pub type ArcLoginProvider = Arc<dyn LoginProvider + Send + Sync>;
 #[derive(Clone, Debug)]
 pub struct Credentials {
     /// The storage credentials are used to authenticate access to the underlying storage (S3, K2V)
-    pub storage: AnyEngine,
+    pub storage: Engine,
     /// The cryptographic keys are used to encrypt and decrypt data stored in S3 and K2V
     pub keys: CryptoKeys,
 }
diff --git a/src/mail/incoming.rs b/src/mail/incoming.rs
index 7094b42..b7d2f48 100644
--- a/src/mail/incoming.rs
+++ b/src/mail/incoming.rs
@@ -23,7 +23,6 @@ use crate::mail::unique_ident::*;
 use crate::mail::user::User;
 use crate::mail::IMF;
 use crate::time::now_msec;
-use crate::storage::Sto;
 
 const INCOMING_PK: &str = "incoming";
 const INCOMING_LOCK_SK: &str = "lock";
@@ -140,14 +139,14 @@ async fn incoming_mail_watch_process_internal(
     Ok(())
 }
 
-async fn handle_incoming_mail<X: Sto>(
+async fn handle_incoming_mail(
     user: &Arc<User>,
     s3: &S3Client,
     inbox: &Arc<Mailbox>,
     lock_held: &watch::Receiver<bool>,
 ) -> Result<()> {
     let lor = ListObjectsV2Request {
-        bucket: user.creds.storage.engine::<X>().bucket.clone(),
+        bucket: user.creds.storage.bucket.clone(),
         max_keys: Some(1000),
         prefix: Some("incoming/".into()),
         ..Default::default()
diff --git a/src/storage/garage.rs b/src/storage/garage.rs
index 965953e..f2cc216 100644
--- a/src/storage/garage.rs
+++ b/src/storage/garage.rs
@@ -1,45 +1,46 @@
 use crate::storage::*;
 
+#[derive(Clone, Debug)]
 pub struct GrgCreds {}
 pub struct GrgStore {}
 pub struct GrgRef {}
 pub struct GrgValue {}
 
 impl IRowBuilder for GrgCreds {
-    fn row_store(&self) -> GrgStore {
+    fn row_store(&self) -> RowStore {
         unimplemented!();
     }
 }
 
 impl IRowStore for GrgStore {
-    fn new_row(&self, partition: &str, sort: &str) -> GrgRef {
+    fn new_row(&self, partition: &str, sort: &str) -> RowRef {
         unimplemented!();
     }
 }
 
 impl IRowRef for GrgRef {
-    fn set_value(&self, content: Vec<u8>) -> GrgValue {
+    fn set_value(&self, content: Vec<u8>) -> RowValue {
         unimplemented!();
     }
-    async fn fetch(&self) -> Result<GrgValue, Error> {
+    fn fetch(&self) -> AsyncResult<RowValue> {
         unimplemented!();
     }
-    async fn rm(&self) -> Result<(), Error> {
+    fn rm(&self) -> AsyncResult<()> {
         unimplemented!();
     }
-    async fn poll(&self) -> Result<Option<GrgValue>, Error> {
+    fn poll(&self) -> AsyncResult<Option<RowValue>> {
         unimplemented!();
     }
 }
 
 impl IRowValue for GrgValue {
-    fn to_ref(&self) -> GrgRef {
+    fn to_ref(&self) -> RowRef {
         unimplemented!();
     }
     fn content(&self) -> ConcurrentValues {
         unimplemented!();
     }
-    async fn push(&self) -> Result<(), Error> {
+    fn push(&self) -> AsyncResult<()> {
         unimplemented!();
     }
 }
diff --git a/src/storage/in_memory.rs b/src/storage/in_memory.rs
index dc3d1e1..fe7c93f 100644
--- a/src/storage/in_memory.rs
+++ b/src/storage/in_memory.rs
@@ -1,45 +1,46 @@
 use crate::storage::*;
 
+#[derive(Clone, Debug)]
 pub struct MemCreds {}
 pub struct MemStore {}
 pub struct MemRef {}
 pub struct MemValue {}
 
 impl IRowBuilder for MemCreds {
-    fn row_store(&self) -> MemStore {
+    fn row_store(&self) -> RowStore {
         unimplemented!();
     }
 }
 
 impl IRowStore for MemStore {
-    fn new_row(&self, partition: &str, sort: &str) -> MemRef {
+    fn new_row(&self, partition: &str, sort: &str) -> RowRef {
         unimplemented!();
     }
 }
 
 impl IRowRef for MemRef {
-    fn set_value(&self, content: Vec<u8>) -> MemValue {
+    fn set_value(&self, content: Vec<u8>) -> RowValue {
         unimplemented!();
     }
-    async fn fetch(&self) -> Result<MemValue, Error> {
+    fn fetch(&self) -> AsyncResult<RowValue> {
         unimplemented!();
     }
-    async fn rm(&self) -> Result<(), Error> {
+    fn rm(&self) -> AsyncResult<()> {
         unimplemented!();
     }
-    async fn poll(&self) -> Result<Option<MemValue>, Error> {
+    fn poll(&self) -> AsyncResult<Option<RowValue>> {
         unimplemented!();
     }
 }
 
 impl IRowValue for MemValue {
-    fn to_ref(&self) -> MemRef {
+    fn to_ref(&self) -> RowRef {
         unimplemented!();
     }
     fn content(&self) -> ConcurrentValues {
         unimplemented!();
     }
-    async fn push(&self) -> Result<(), Error> {
+    fn push(&self) -> AsyncResult<()> {
         unimplemented!();
     }
 }
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index 82f7c6a..b5c8518 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -8,6 +8,8 @@
  * into the object system so it is not exposed.
  */
 
+use futures::future::BoxFuture;
+
 pub mod in_memory;
 pub mod garage;
 
@@ -32,13 +34,29 @@ pub struct Engine {
     pub bucket: String,
     pub row: RowBuilder,
 }
+impl Clone for Engine {
+    fn clone(&self) -> Self {
+        Engine {
+            bucket: "test".into(),
+            row: Box::new(in_memory::MemCreds{})
+        }
+    }
+}
+impl std::fmt::Debug for Engine {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Engine").field("bucket", &self.bucket).finish()
+    }
+}
+
+// A result
+pub type AsyncResult<'a, T> = BoxFuture<'a, Result<T, Error>>;
 
 // ------ Row Builder
 pub trait IRowBuilder
 {
     fn row_store(&self) -> RowStore;
 }
-pub type RowBuilder = Box<dyn IRowBuilder>;
+pub type RowBuilder = Box<dyn IRowBuilder + Send + Sync>;
 
 // ------ Row Store
 pub trait IRowStore
@@ -51,9 +69,9 @@ type RowStore = Box<dyn IRowStore>;
 pub trait IRowRef 
 {
     fn set_value(&self, content: Vec<u8>) -> RowValue;
-    async fn fetch(&self) -> Result<RowValue, Error>;
-    async fn rm(&self) -> Result<(), Error>;
-    async fn poll(&self) -> Result<Option<RowValue>, Error>;
+    fn fetch(&self) -> AsyncResult<RowValue>;
+    fn rm(&self) -> AsyncResult<()>;
+    fn poll(&self) -> AsyncResult<Option<RowValue>>;
 }
 type RowRef = Box<dyn IRowRef>;
 
@@ -61,6 +79,6 @@ pub trait IRowValue
 {
     fn to_ref(&self) -> RowRef;
     fn content(&self) -> ConcurrentValues;
-    async fn push(&self) -> Result<(), Error>;
+    fn push(&self) -> AsyncResult<()>;
 }
 type RowValue = Box<dyn IRowValue>;