diff --git a/editoast/editoast_derive/src/model.rs b/editoast/editoast_derive/src/model.rs
index 2068a5dc5ea..9a242cd089f 100644
--- a/editoast/editoast_derive/src/model.rs
+++ b/editoast/editoast_derive/src/model.rs
@@ -84,7 +84,7 @@ fn create_functions(config: &Config) -> TokenStream {
     quote! {
         #[async_trait::async_trait]
         impl crate::models::Create for #model_name {
-            async fn create_conn(self, conn: &mut editoast_models::DbConnection) -> crate::error::Result<Self> {
+            async fn create_conn(self, conn: &mut editoast_models::DieselConnection) -> crate::error::Result<Self> {
                 use #table::table;
                 use diesel_async::RunQueryDsl;
 
@@ -126,7 +126,7 @@ fn retrieve_functions(config: &Config) -> TokenStream {
     quote! {
         #[async_trait::async_trait]
         impl crate::models::Retrieve for #model_name {
-            async fn retrieve_conn(conn: &mut editoast_models::DbConnection, obj_id: i64) -> crate::error::Result<Option<Self>> {
+            async fn retrieve_conn(conn: &mut editoast_models::DieselConnection, obj_id: i64) -> crate::error::Result<Option<Self>> {
                 use #table::table;
                 use #table::dsl;
                 use diesel_async::RunQueryDsl;
@@ -174,7 +174,7 @@ fn delete_functions(config: &Config) -> TokenStream {
     quote! {
         #[async_trait::async_trait]
         impl crate::models::Delete for #model_name {
-            async fn delete_conn(conn: &mut editoast_models::DbConnection, obj_id: i64) -> crate::error::Result<bool> {
+            async fn delete_conn(conn: &mut editoast_models::DieselConnection, obj_id: i64) -> crate::error::Result<bool> {
                 use #table::table;
                 use #table::dsl;
                 use diesel_async::RunQueryDsl;
@@ -207,7 +207,7 @@ fn update_functions(config: &Config) -> TokenStream {
     quote! {
         #[async_trait::async_trait]
         impl crate::models::Update for #model_name {
-            async fn update_conn(self, conn: &mut editoast_models::DbConnection, obj_id: i64) -> crate::error::Result<Option<Self>> {
+            async fn update_conn(self, conn: &mut editoast_models::DieselConnection, obj_id: i64) -> crate::error::Result<Option<Self>> {
                 use #table::table;
 
                 match diesel::update(table.find(obj_id)).set(&self).get_result(conn).await
diff --git a/editoast/editoast_derive/src/modelv2/codegen/count_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/count_impl.rs
index 44f621ab587..3472c8e5f69 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/count_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/count_impl.rs
@@ -28,6 +28,7 @@ impl ToTokens for CountImpl {
                     use diesel::QueryDsl;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
+                    use std::ops::DerefMut;
 
                     let mut query = #table_mod::table.select(diesel::dsl::count_star()).into_boxed();
 
@@ -48,7 +49,7 @@ impl ToTokens for CountImpl {
                         }
                     }
 
-                    Ok(query.get_result::<i64>(conn).await? as u64)
+                    Ok(query.get_result::<i64>(conn.write().await.deref_mut()).await? as u64)
                 }
             }
 
diff --git a/editoast/editoast_derive/src/modelv2/codegen/create_batch_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/create_batch_impl.rs
index 34a7439ec29..587ff917411 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/create_batch_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/create_batch_impl.rs
@@ -38,6 +38,7 @@ impl ToTokens for CreateBatchImpl {
                 ) -> crate::error::Result<C> {
                     use crate::modelsv2::Model;
                     use #table_mod::dsl;
+                    use std::ops::DerefMut;
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
@@ -50,7 +51,7 @@ impl ToTokens for CreateBatchImpl {
                         chunk => {
                             diesel::insert_into(dsl::#table_name)
                                 .values(chunk)
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| s.map_ok(<#model as Model>::from_row).try_collect::<Vec<_>>())?
                                 .await?
diff --git a/editoast/editoast_derive/src/modelv2/codegen/create_batch_with_key_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/create_batch_with_key_impl.rs
index 03456ac3143..775b4fd3031 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/create_batch_with_key_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/create_batch_with_key_impl.rs
@@ -43,6 +43,7 @@ impl ToTokens for CreateBatchWithKeyImpl {
                 ) -> crate::error::Result<C> {
                     use crate::models::Identifiable;
                     use crate::modelsv2::Model;
+                    use std::ops::DerefMut;
                     use #table_mod::dsl;
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
@@ -56,7 +57,7 @@ impl ToTokens for CreateBatchWithKeyImpl {
                         chunk => {
                             diesel::insert_into(dsl::#table_name)
                                 .values(chunk)
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| {
                                     s.map_ok(|row| {
diff --git a/editoast/editoast_derive/src/modelv2/codegen/create_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/create_impl.rs
index 4a4911883fd..44ed1e2bb38 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/create_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/create_impl.rs
@@ -28,9 +28,10 @@ impl ToTokens for CreateImpl {
                     conn: &mut editoast_models::DbConnection,
                 ) -> crate::error::Result<#model> {
                     use diesel_async::RunQueryDsl;
+                    use std::ops::DerefMut;
                     diesel::insert_into(#table_mod::table)
                         .values(&self)
-                        .get_result::<#row>(conn)
+                        .get_result::<#row>(conn.write().await.deref_mut())
                         .await
                         .map(Into::into)
                         .map_err(Into::into)
diff --git a/editoast/editoast_derive/src/modelv2/codegen/delete_batch_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/delete_batch_impl.rs
index 11b10dbd6c0..2b7ec5457e5 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/delete_batch_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/delete_batch_impl.rs
@@ -38,6 +38,7 @@ impl ToTokens for DeleteBatchImpl {
                     use #table_mod::dsl;
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
+                    use std::ops::DerefMut;
                     let ids = ids.into_iter().collect::<Vec<_>>();
                     tracing::Span::current().record("query_ids", tracing::field::debug(&ids));
                     let counts = crate::chunked_for_libpq! {
@@ -49,7 +50,7 @@ impl ToTokens for DeleteBatchImpl {
                             for #id_ident in chunk.into_iter() {
                                 query = query.or_filter(#filters);
                             }
-                            query.execute(conn).await?
+                            query.execute(conn.write().await.deref_mut()).await?
                         }
                     };
                     Ok(counts.into_iter().sum())
diff --git a/editoast/editoast_derive/src/modelv2/codegen/delete_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/delete_impl.rs
index e13ff089ae1..2a7a7454920 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/delete_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/delete_impl.rs
@@ -28,9 +28,10 @@ impl ToTokens for DeleteImpl {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use #table_mod::dsl;
+                    use std::ops::DerefMut;
                     let id = self.#primary_key;
                     diesel::delete(#table_mod::table.find(id))
-                        .execute(conn)
+                        .execute(conn.write().await.deref_mut())
                         .await
                         .map(|n| n == 1)
                         .map_err(Into::into)
diff --git a/editoast/editoast_derive/src/modelv2/codegen/delete_static_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/delete_static_impl.rs
index c7fc8840a54..9b9981fa0f1 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/delete_static_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/delete_static_impl.rs
@@ -35,10 +35,11 @@ impl ToTokens for DeleteStaticImpl {
                 ) -> crate::error::Result<bool> {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
+                    use std::ops::DerefMut;
                     use #table_mod::dsl;
                     tracing::Span::current().record("query_id", tracing::field::debug(#id_ref_ident));
                     diesel::delete(dsl::#table_name.#(filter(#eqs)).*)
-                        .execute(conn)
+                        .execute(conn.write().await.deref_mut())
                         .await
                         .map(|n| n == 1)
                         .map_err(Into::into)
diff --git a/editoast/editoast_derive/src/modelv2/codegen/exists_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/exists_impl.rs
index 76176a6a0c8..4e0d0125065 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/exists_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/exists_impl.rs
@@ -35,10 +35,11 @@ impl ToTokens for ExistsImpl {
                 ) -> crate::error::Result<bool> {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
+                    use std::ops::DerefMut;
                     use #table_mod::dsl;
                     tracing::Span::current().record("query_id", tracing::field::debug(#id_ref_ident));
                     diesel::select(diesel::dsl::exists(dsl::#table_name.#(filter(#eqs)).*))
-                        .get_result(conn)
+                        .get_result(conn.write().await.deref_mut())
                         .await
                         .map_err(Into::into)
                 }
diff --git a/editoast/editoast_derive/src/modelv2/codegen/list_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/list_impl.rs
index f1e9ef0f066..2518a510e93 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/list_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/list_impl.rs
@@ -34,6 +34,7 @@ impl ToTokens for ListImpl {
                     use diesel::QueryDsl;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
+                    use std::ops::DerefMut;
 
                     let mut query = #table_mod::table.into_boxed();
 
@@ -58,7 +59,7 @@ impl ToTokens for ListImpl {
                     }
 
                     let results: Vec<#model> = query
-                        .load_stream::<#row>(conn)
+                        .load_stream::<#row>(conn.write().await.deref_mut())
                         .await?
                         .map_ok(<#model as crate::modelsv2::prelude::Model>::from_row)
                         .try_collect()
diff --git a/editoast/editoast_derive/src/modelv2/codegen/retrieve_batch_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/retrieve_batch_impl.rs
index 3a637bf0d11..52f773d8a00 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/retrieve_batch_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/retrieve_batch_impl.rs
@@ -46,6 +46,7 @@ impl ToTokens for RetrieveBatchImpl {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
+                    use std::ops::DerefMut;
                     let ids = ids.into_iter().collect::<Vec<_>>();
                     tracing::Span::current().record("query_ids", tracing::field::debug(&ids));
                     Ok(crate::chunked_for_libpq! {
@@ -62,7 +63,7 @@ impl ToTokens for RetrieveBatchImpl {
                                 query = query.or_filter(#filters);
                             }
                             query
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| s.map_ok(<#model as Model>::from_row).try_collect::<Vec<_>>())?
                                 .await?
@@ -84,6 +85,7 @@ impl ToTokens for RetrieveBatchImpl {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
+                    use std::ops::DerefMut;
                     let ids = ids.into_iter().collect::<Vec<_>>();
                     tracing::Span::current().record("query_ids", tracing::field::debug(&ids));
                     Ok(crate::chunked_for_libpq! {
@@ -97,7 +99,7 @@ impl ToTokens for RetrieveBatchImpl {
                                 query = query.or_filter(#filters);
                             }
                             query
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| {
                                     s.map_ok(|row| {
diff --git a/editoast/editoast_derive/src/modelv2/codegen/retrieve_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/retrieve_impl.rs
index 5284430ddb8..80c08ce88ba 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/retrieve_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/retrieve_impl.rs
@@ -38,10 +38,11 @@ impl ToTokens for RetrieveImpl {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use #table_mod::dsl;
+                    use std::ops::DerefMut;
                     tracing::Span::current().record("query_id", tracing::field::debug(#id_ref_ident));
                     dsl::#table_name
                         .#(filter(#eqs)).*
-                        .first::<#row>(conn)
+                        .first::<#row>(conn.write().await.deref_mut())
                         .await
                         .map(Into::into)
                         .optional()
diff --git a/editoast/editoast_derive/src/modelv2/codegen/update_batch_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/update_batch_impl.rs
index 8eb568f6b7e..7d71e0d28a4 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/update_batch_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/update_batch_impl.rs
@@ -51,6 +51,7 @@ impl ToTokens for UpdateBatchImpl {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
+                    use std::ops::DerefMut;
                     let ids = ids.into_iter().collect::<Vec<_>>();
                     tracing::Span::current().record("query_ids", tracing::field::debug(&ids));
                     Ok(crate::chunked_for_libpq! {
@@ -69,7 +70,7 @@ impl ToTokens for UpdateBatchImpl {
                             diesel::update(dsl::#table_name)
                                 .filter(dsl::#primary_key_column.eq_any(query))
                                 .set(&self)
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| s.map_ok(<#model as Model>::from_row).try_collect::<Vec<_>>())?
                                 .await?
@@ -89,6 +90,7 @@ impl ToTokens for UpdateBatchImpl {
                     use crate::models::Identifiable;
                     use crate::modelsv2::Model;
                     use #table_mod::dsl;
+                    use std::ops::DerefMut;
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
                     use futures_util::stream::TryStreamExt;
@@ -109,7 +111,7 @@ impl ToTokens for UpdateBatchImpl {
                             diesel::update(dsl::#table_name)
                                 .filter(dsl::#primary_key_column.eq_any(query))
                                 .set(&self)
-                                .load_stream::<#row>(conn)
+                                .load_stream::<#row>(conn.write().await.deref_mut())
                                 .await
                                 .map(|s| {
                                     s.map_ok(|row| {
diff --git a/editoast/editoast_derive/src/modelv2/codegen/update_impl.rs b/editoast/editoast_derive/src/modelv2/codegen/update_impl.rs
index 97354184cdd..06eec25c866 100644
--- a/editoast/editoast_derive/src/modelv2/codegen/update_impl.rs
+++ b/editoast/editoast_derive/src/modelv2/codegen/update_impl.rs
@@ -40,11 +40,12 @@ impl ToTokens for UpdateImpl {
                 ) -> crate::error::Result<Option<#model>> {
                     use diesel::prelude::*;
                     use diesel_async::RunQueryDsl;
+                    use std::ops::DerefMut;
                     use #table_mod::dsl;
                     tracing::Span::current().record("query_id", tracing::field::debug(#id_ref_ident));
                     diesel::update(dsl::#table_name.#(filter(#eqs)).*)
                         .set(&self)
-                        .get_result::<#row>(conn)
+                        .get_result::<#row>(conn.write().await.deref_mut())
                         .await
                         .map(Into::into)
                         .optional()
diff --git a/editoast/editoast_models/src/db_connection_pool.rs b/editoast/editoast_models/src/db_connection_pool.rs
index e2d4e37595f..348ff3e1e25 100644
--- a/editoast/editoast_models/src/db_connection_pool.rs
+++ b/editoast/editoast_models/src/db_connection_pool.rs
@@ -1,3 +1,5 @@
+use std::ops::Deref;
+use std::ops::DerefMut;
 use std::sync::Arc;
 
 use diesel::sql_query;
@@ -7,6 +9,8 @@ use diesel_async::pooled_connection::deadpool::Object;
 use diesel_async::pooled_connection::deadpool::Pool;
 use diesel_async::pooled_connection::AsyncDieselConnectionManager;
 use diesel_async::pooled_connection::ManagerConfig;
+use diesel_async::scoped_futures::ScopedBoxFuture;
+use diesel_async::AsyncConnection;
 use diesel_async::AsyncPgConnection;
 use diesel_async::RunQueryDsl;
 use futures::future::BoxFuture;
@@ -17,21 +21,87 @@ use openssl::ssl::SslMethod;
 use openssl::ssl::SslVerifyMode;
 use url::Url;
 
-#[cfg(feature = "testing")]
 use tokio::sync::OwnedRwLockWriteGuard;
-#[cfg(feature = "testing")]
 use tokio::sync::RwLock;
 
-use super::DbConnection;
 use super::DbConnectionPool;
+use super::DieselConnection;
 
 pub type DbConnectionConfig = AsyncDieselConnectionManager<AsyncPgConnection>;
 
-#[cfg(feature = "testing")]
-pub type DbConnectionV2 = OwnedRwLockWriteGuard<Object<AsyncPgConnection>>;
+#[derive(Clone)]
+pub struct DbConnection {
+    inner: Arc<RwLock<Object<AsyncPgConnection>>>,
+}
+
+pub struct WriteHandle {
+    guard: OwnedRwLockWriteGuard<Object<AsyncPgConnection>>,
+}
+
+impl DbConnection {
+    pub fn new(inner: Arc<RwLock<Object<AsyncPgConnection>>>) -> Self {
+        Self { inner }
+    }
+
+    pub async fn write(&self) -> WriteHandle {
+        WriteHandle {
+            guard: self.inner.clone().write_owned().await,
+        }
+    }
+
+    // Implementation of this function is taking a strong inspiration from
+    // https://docs.rs/diesel/2.1.6/src/diesel/connection/transaction_manager.rs.html#50-71
+    // Sadly, this function is private so we can't use it.
+    //
+    // :WARNING: If you ever need to modify this function, please take a look at the
+    // original `diesel` function, they probably do it right more than us.
+    pub async fn transaction<'a, R, E, F>(self, callback: F) -> std::result::Result<R, E>
+    where
+        F: FnOnce(Self) -> ScopedBoxFuture<'a, 'a, std::result::Result<R, E>> + Send + 'a,
+        E: From<diesel::result::Error> + Send + 'a,
+        R: Send + 'a,
+    {
+        use diesel_async::TransactionManager as _;
+
+        type TxManager = <AsyncPgConnection as AsyncConnection>::TransactionManager;
 
-#[cfg(not(feature = "testing"))]
-pub type DbConnectionV2 = Object<AsyncPgConnection>;
+        {
+            let mut handle = self.write().await;
+            TxManager::begin_transaction(handle.deref_mut()).await?;
+        }
+
+        match callback(self.clone()).await {
+            Ok(result) => {
+                let mut handle = self.write().await;
+                TxManager::commit_transaction(handle.deref_mut()).await?;
+                Ok(result)
+            }
+            Err(callback_error) => {
+                let mut handle = self.write().await;
+                match TxManager::rollback_transaction(handle.deref_mut()).await {
+                    Ok(()) | Err(diesel::result::Error::BrokenTransactionManager) => {
+                        Err(callback_error)
+                    }
+                    Err(rollback_error) => Err(rollback_error.into()),
+                }
+            }
+        }
+    }
+}
+
+impl Deref for WriteHandle {
+    type Target = AsyncPgConnection;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard.deref()
+    }
+}
+
+impl DerefMut for WriteHandle {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard.deref_mut()
+    }
+}
 
 /// Wrapper for connection pooling with support for test connections on `cfg(test)`
 ///
@@ -46,7 +116,7 @@ pub type DbConnectionV2 = Object<AsyncPgConnection>;
 pub struct DbConnectionPoolV2 {
     pool: Arc<Pool<AsyncPgConnection>>,
     #[cfg(feature = "testing")]
-    test_connection: Option<Arc<RwLock<Object<AsyncPgConnection>>>>,
+    test_connection: Option<DbConnection>,
 }
 
 #[cfg(feature = "testing")]
@@ -79,20 +149,18 @@ impl DbConnectionPoolV2 {
     }
 
     #[cfg(feature = "testing")]
-    async fn get_connection(&self) -> Result<DbConnectionV2, DatabasePoolError> {
-        let Some(test_connection) = &self.test_connection else {
-            panic!(
-                "Test connection not initialized in test DatabasePool -- was `for_tests` called?"
-            );
-        };
-        let connection = test_connection.clone().write_owned().await;
-        Ok(connection)
+    async fn get_connection(&self) -> Result<DbConnection, DatabasePoolError> {
+        Ok(self
+            .test_connection
+            .as_ref()
+            .expect("should already exist")
+            .clone())
     }
 
     #[cfg(not(feature = "testing"))]
-    async fn get_connection(&self) -> Result<DbConnectionV2, DatabasePoolError> {
+    async fn get_connection(&self) -> Result<DbConnection, DatabasePoolError> {
         let connection = self.pool.get().await?;
-        Ok(connection)
+        Ok(DbConnection::new(Arc::new(RwLock::new(connection))))
     }
 
     /// Get a connection from the pool
@@ -159,7 +227,7 @@ impl DbConnectionPoolV2 {
     /// - Don't declare a variable for a single-use connection:
     ///
     /// ```
-    /// # async fn my_function_using_conn(conn: tokio::sync::OwnedRwLockWriteGuard<diesel_async::pooled_connection::deadpool::Object<diesel_async::AsyncPgConnection>>) {
+    /// # async fn my_function_using_conn(conn: &mut editoast_models::DbConnection) {
     /// #   // Do something with the connection
     /// # }
     /// #
@@ -167,10 +235,10 @@ impl DbConnectionPoolV2 {
     /// # async fn main() -> Result<(), editoast_models::db_connection_pool::DatabasePoolError> {
     /// let pool = editoast_models::DbConnectionPoolV2::for_tests();
     /// // do
-    /// my_function_using_conn(pool.get().await?).await;
+    /// my_function_using_conn(&mut pool.get().await?).await;
     /// // instead of
-    /// let conn = pool.get().await?;
-    /// my_function_using_conn(conn).await;
+    /// let mut conn = pool.get().await?;
+    /// my_function_using_conn(&mut conn).await;
     /// # Ok(())
     /// # }
     /// ```
@@ -178,10 +246,10 @@ impl DbConnectionPoolV2 {
     /// - If a connection is used repeatedly, prefer using explicit scoping:
     ///
     /// ```
-    /// # async fn foo(conn: &mut tokio::sync::OwnedRwLockWriteGuard<diesel_async::pooled_connection::deadpool::Object<diesel_async::AsyncPgConnection>>) -> u8 {
+    /// # async fn foo(conn: &mut editoast_models::DbConnection) -> u8 {
     /// #   0
     /// # }
-    /// # async fn bar(conn: &mut tokio::sync::OwnedRwLockWriteGuard<diesel_async::pooled_connection::deadpool::Object<diesel_async::AsyncPgConnection>>) -> u8 {
+    /// # async fn bar(conn: &mut editoast_models::DbConnection) -> u8 {
     /// #   42
     /// # }
     /// # #[tokio::main]
@@ -202,7 +270,7 @@ impl DbConnectionPoolV2 {
     ///
     /// ```
     /// # trait DoSomething: Sized {
-    /// #   async fn do_something(self, conn: tokio::sync::OwnedRwLockWriteGuard<diesel_async::pooled_connection::deadpool::Object<diesel_async::AsyncPgConnection>>) -> Result<(), editoast_models::db_connection_pool::DatabasePoolError> {
+    /// #   async fn do_something(self, conn: &mut editoast_models::DbConnection) -> Result<(), editoast_models::db_connection_pool::DatabasePoolError> {
     /// #     // Do something with the connection
     /// #     Ok(())
     /// #   }
@@ -216,15 +284,15 @@ impl DbConnectionPoolV2 {
     ///     items.into_iter()
     ///         .zip(pool.iter_conn())
     ///         .map(|(item, conn)| async move {
-    ///             let conn = conn.await?; // note the await here
-    ///             item.do_something(conn).await
+    ///             let mut conn = conn.await?; // note the await here
+    ///             item.do_something(&mut conn).await
     ///         });
     /// let results = futures::future::try_join_all(operations).await?;
     /// // you may acquire a new connection afterwards
     /// # Ok(())
     /// # }
     /// ```
-    pub async fn get(&self) -> Result<DbConnectionV2, DatabasePoolError> {
+    pub async fn get(&self) -> Result<DbConnection, DatabasePoolError> {
         self.get_connection().await
     }
 
@@ -235,7 +303,7 @@ impl DbConnectionPoolV2 {
     /// See [DbConnectionPoolV2::get] for more information on how connections should be used
     /// in tests.
     #[cfg(feature = "testing")]
-    pub fn get_ok(&self) -> DbConnectionV2 {
+    pub fn get_ok(&self) -> DbConnection {
         futures::executor::block_on(self.get()).expect("Failed to get test connection")
     }
 
@@ -247,7 +315,7 @@ impl DbConnectionPoolV2 {
     ///
     /// ```
     /// # trait DoSomething: Sized {
-    /// #   async fn do_something(self, conn: tokio::sync::OwnedRwLockWriteGuard<diesel_async::pooled_connection::deadpool::Object<diesel_async::AsyncPgConnection>>) -> Result<(), editoast_models::db_connection_pool::DatabasePoolError> {
+    /// #   async fn do_something(self, conn: &mut editoast_models::DbConnection) -> Result<(), editoast_models::db_connection_pool::DatabasePoolError> {
     /// #     // Do something with the connection
     /// #     Ok(())
     /// #   }
@@ -261,8 +329,8 @@ impl DbConnectionPoolV2 {
     ///     items.into_iter()
     ///         .zip(pool.iter_conn())
     ///         .map(|(item, conn)| async move {
-    ///             let conn = conn.await?; // note the await here
-    ///             item.do_something(conn).await
+    ///             let mut conn = conn.await?; // note the await here
+    ///             item.do_something(&mut conn).await
     ///         });
     /// let results = futures::future::try_join_all(operations).await?;
     /// // you may acquire a new connection afterwards
@@ -271,7 +339,7 @@ impl DbConnectionPoolV2 {
     /// ```
     pub fn iter_conn(
         &self,
-    ) -> impl Iterator<Item = impl Future<Output = Result<DbConnectionV2, DatabasePoolError>> + '_>
+    ) -> impl Iterator<Item = impl Future<Output = Result<DbConnection, DatabasePoolError>> + '_>
     {
         std::iter::repeat_with(|| self.get())
     }
@@ -298,11 +366,11 @@ impl DbConnectionPoolV2 {
                 .await
                 .expect("cannot begin a test transaction");
         }
-        let test_connection = Arc::new(RwLock::new(conn));
+        let test_connection = Some(DbConnection::new(Arc::new(RwLock::new(conn))));
 
         Self {
             pool,
-            test_connection: Some(test_connection),
+            test_connection,
         }
     }
 
@@ -312,7 +380,7 @@ impl DbConnectionPoolV2 {
             .unwrap_or_else(|_| String::from("postgresql://osrd:password@localhost/osrd"));
         let url = Url::parse(&url).expect("Failed to parse postgresql url");
         let pool =
-            create_connection_pool(url, 1).expect("Failed to initialize test connection pool");
+            create_connection_pool(url, 2).expect("Failed to initialize test connection pool");
         futures::executor::block_on(Self::from_pool_test(Arc::new(pool), transaction))
     }
 
@@ -339,7 +407,9 @@ impl DbConnectionPoolV2 {
 pub struct PingError(#[from] diesel::result::Error);
 
 pub async fn ping_database(conn: &mut DbConnection) -> Result<(), PingError> {
-    sql_query("SELECT 1").execute(conn).await?;
+    sql_query("SELECT 1")
+        .execute(conn.write().await.deref_mut())
+        .await?;
     Ok(())
 }
 
@@ -353,7 +423,7 @@ pub fn create_connection_pool(
     Ok(Pool::builder(manager).max_size(max_size).build()?)
 }
 
-fn establish_connection(config: &str) -> BoxFuture<ConnectionResult<DbConnection>> {
+fn establish_connection(config: &str) -> BoxFuture<ConnectionResult<DieselConnection>> {
     let fut = async {
         let mut connector_builder = SslConnector::builder(SslMethod::tls()).unwrap();
         connector_builder.set_verify(SslVerifyMode::NONE);
@@ -368,7 +438,7 @@ fn establish_connection(config: &str) -> BoxFuture<ConnectionResult<DbConnection
                 tracing::error!("connection error: {}", e);
             }
         });
-        DbConnection::try_from(client).await
+        DieselConnection::try_from(client).await
     };
     fut.boxed()
 }
diff --git a/editoast/editoast_models/src/lib.rs b/editoast/editoast_models/src/lib.rs
index 4f690c7f55d..079c7f87bed 100644
--- a/editoast/editoast_models/src/lib.rs
+++ b/editoast/editoast_models/src/lib.rs
@@ -1,12 +1,14 @@
-use diesel_async::{pooled_connection::deadpool::Pool, AsyncPgConnection};
+use diesel_async::pooled_connection::deadpool::Pool;
+use diesel_async::AsyncPgConnection;
 
 pub mod db_connection_pool;
 pub mod tables;
 
+pub use db_connection_pool::DbConnection;
 pub use db_connection_pool::DbConnectionPoolV2;
 
-pub type DbConnection = AsyncPgConnection;
-pub type DbConnectionPool = Pool<DbConnection>;
+type DieselConnection = AsyncPgConnection;
+pub type DbConnectionPool = Pool<DieselConnection>;
 
 /// Generic error type to forward errors from the database
 ///
diff --git a/editoast/src/generated_data/buffer_stop.rs b/editoast/src/generated_data/buffer_stop.rs
index df57b1125d9..532674460f9 100644
--- a/editoast/src/generated_data/buffer_stop.rs
+++ b/editoast/src/generated_data/buffer_stop.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_buffer_stop::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_buffer_stop::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct BufferStopLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for BufferStopLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         let _res = sql_query(include_str!("sql/generate_buffer_stop_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -49,7 +51,7 @@ impl GeneratedData for BufferStopLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(involved_objects.deleted)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -58,7 +60,7 @@ impl GeneratedData for BufferStopLayer {
             sql_query(include_str!("sql/insert_update_buffer_stop_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/detector.rs b/editoast/src/generated_data/detector.rs
index bb50af54394..9faf98a8812 100644
--- a/editoast/src/generated_data/detector.rs
+++ b/editoast/src/generated_data/detector.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_detector::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_detector::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct DetectorLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for DetectorLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_detector_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -49,7 +51,7 @@ impl GeneratedData for DetectorLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(involved_objects.deleted)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -58,7 +60,7 @@ impl GeneratedData for DetectorLayer {
             sql_query(include_str!("sql/insert_update_detector_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/electrification.rs b/editoast/src/generated_data/electrification.rs
index 3dd3fd91cda..252424807a8 100644
--- a/editoast/src/generated_data/electrification.rs
+++ b/editoast/src/generated_data/electrification.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_electrification::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_electrification::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct ElectrificationLayer;
 
@@ -32,7 +34,7 @@ impl GeneratedData for ElectrificationLayer {
     ) -> Result<()> {
         sql_query(include_str!("sql/generate_electrification_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -59,7 +61,7 @@ impl GeneratedData for ElectrificationLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(objs)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -68,7 +70,7 @@ impl GeneratedData for ElectrificationLayer {
             sql_query(include_str!("sql/insert_electrification_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/error/mod.rs b/editoast/src/generated_data/error/mod.rs
index 106a512d0d0..2bf4e21353a 100644
--- a/editoast/src/generated_data/error/mod.rs
+++ b/editoast/src/generated_data/error/mod.rs
@@ -22,11 +22,15 @@ use diesel::sql_types::BigInt;
 use diesel::sql_types::Json;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::OSRDObject;
+use editoast_schemas::primitives::ObjectType;
 use futures_util::Future;
 use itertools::Itertools;
 use serde_json::to_value;
 use sha1::Digest;
 use sha1::Sha1;
+use std::ops::DerefMut;
 use tracing::warn;
 
 use super::GeneratedData;
@@ -36,9 +40,6 @@ use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::Graph;
 use crate::infra_cache::InfraCache;
 use crate::infra_cache::ObjectCache;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::OSRDObject;
-use editoast_schemas::primitives::ObjectType;
 
 editoast_common::schemas! {
     infra_error::schemas(),
@@ -308,7 +309,7 @@ async fn retrieve_current_errors_hash(
     Ok(dsl::infra_layer_error
         .filter(dsl::infra_id.eq(infra_id))
         .select(dsl::info_hash)
-        .load(conn)
+        .load(conn.write().await.deref_mut())
         .await?)
 }
 
@@ -324,7 +325,7 @@ async fn remove_errors_from_hashes(
             .filter(dsl::infra_id.eq(infra_id))
             .filter(dsl::info_hash.eq_any(errors_hash)),
     )
-    .execute(conn)
+    .execute(conn.write().await.deref_mut())
     .await?;
     debug_assert_eq!(nb_deleted, errors_hash.len());
     Ok(())
@@ -349,7 +350,7 @@ async fn create_errors(
             .bind::<BigInt, _>(infra_id)
             .bind::<Array<Json>, _>(&errors_information)
             .bind::<Array<Text>, _>(&errors_hash)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         assert_eq!(count, errors_hash.len());
     }
diff --git a/editoast/src/generated_data/mod.rs b/editoast/src/generated_data/mod.rs
index a87f7414599..0e00ef300d4 100644
--- a/editoast/src/generated_data/mod.rs
+++ b/editoast/src/generated_data/mod.rs
@@ -59,7 +59,7 @@ pub trait GeneratedData {
             Self::table_name()
         ))
         .bind::<BigInt, _>(infra)
-        .execute(conn)
+        .execute(conn.write().await.deref_mut())
         .await?;
         Ok(())
     }
@@ -74,7 +74,7 @@ pub trait GeneratedData {
         infra: i64,
         infra_cache: &InfraCache,
     ) -> Result<()> {
-        Self::refresh(pool.get().await?.deref_mut(), infra, infra_cache).await
+        Self::refresh(&mut pool.get().await?, infra, infra_cache).await
     }
 
     /// Search and update all objects that needs to be refreshed given a list of operation.
@@ -101,7 +101,7 @@ pub async fn refresh_all(
     // It doesn’t seem to make a different when the generation step is ran separately
     // It isn’t clear why without analyze the Postgres server seems to run at 100% without halting
     sql_query("analyze")
-        .execute(db_pool.get().await?.deref_mut())
+        .execute(&mut db_pool.get().await?.write().await.deref_mut())
         .await?;
     debug!("⚙️ Infra {infra_id}: database analyzed");
     futures::try_join!(
@@ -165,7 +165,6 @@ pub async fn update_all(
 #[cfg(test)]
 pub mod tests {
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use crate::generated_data::clear_all;
     use crate::generated_data::refresh_all;
@@ -179,7 +178,7 @@ pub mod tests {
     #[serial_test::serial]
     async fn refresh_all_test() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         assert!(refresh_all(db_pool.into(), infra.id, &Default::default())
             .await
             .is_ok());
@@ -188,23 +187,18 @@ pub mod tests {
     #[rstest]
     async fn update_all_test() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        assert!(update_all(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            &[],
-            &Default::default()
-        )
-        .await
-        .is_ok());
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        assert!(
+            update_all(&mut db_pool.get_ok(), infra.id, &[], &Default::default())
+                .await
+                .is_ok()
+        );
     }
 
     #[rstest]
     async fn clear_all_test() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        assert!(clear_all(db_pool.get_ok().deref_mut(), infra.id)
-            .await
-            .is_ok());
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        assert!(clear_all(&mut db_pool.get_ok(), infra.id).await.is_ok());
     }
 }
diff --git a/editoast/src/generated_data/neutral_section.rs b/editoast/src/generated_data/neutral_section.rs
index 966053a98b4..b6c43111936 100644
--- a/editoast/src/generated_data/neutral_section.rs
+++ b/editoast/src/generated_data/neutral_section.rs
@@ -1,13 +1,15 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 
 use super::GeneratedData;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::DbConnection;
 
 pub struct NeutralSectionLayer;
 
@@ -20,7 +22,7 @@ impl GeneratedData for NeutralSectionLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_neutral_section_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
diff --git a/editoast/src/generated_data/neutral_sign.rs b/editoast/src/generated_data/neutral_sign.rs
index 74bbbd5c46e..379145aa5e1 100644
--- a/editoast/src/generated_data/neutral_sign.rs
+++ b/editoast/src/generated_data/neutral_sign.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_neutral_sign::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_neutral_sign::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct NeutralSignLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for NeutralSignLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_neutral_sign_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -52,7 +54,7 @@ impl GeneratedData for NeutralSignLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(objs)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -61,7 +63,7 @@ impl GeneratedData for NeutralSignLayer {
             sql_query(include_str!("sql/insert_neutral_sign_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/operational_point.rs b/editoast/src/generated_data/operational_point.rs
index 956fadc65e5..618ddbc475e 100644
--- a/editoast/src/generated_data/operational_point.rs
+++ b/editoast/src/generated_data/operational_point.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_operational_point::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_operational_point::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct OperationalPointLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for OperationalPointLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_operational_point_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -55,7 +57,7 @@ impl GeneratedData for OperationalPointLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(objs)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -64,7 +66,7 @@ impl GeneratedData for OperationalPointLayer {
             sql_query(include_str!("sql/insert_operational_point_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/psl_sign.rs b/editoast/src/generated_data/psl_sign.rs
index 77a316f7bec..c774725c7d0 100644
--- a/editoast/src/generated_data/psl_sign.rs
+++ b/editoast/src/generated_data/psl_sign.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_psl_sign::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_psl_sign::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct PSLSignLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for PSLSignLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_psl_sign_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -54,7 +56,7 @@ impl GeneratedData for PSLSignLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(objs)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -63,7 +65,7 @@ impl GeneratedData for PSLSignLayer {
             sql_query(include_str!("sql/insert_psl_sign_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/signal.rs b/editoast/src/generated_data/signal.rs
index 123dd8e060f..f6fc146594e 100644
--- a/editoast/src/generated_data/signal.rs
+++ b/editoast/src/generated_data/signal.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::ops::DerefMut;
 
 use async_trait::async_trait;
 use diesel::delete;
@@ -8,6 +9,10 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Nullable;
 use diesel::sql_types::Text;
+use editoast_models::tables::infra_layer_signal::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::infra::LogicalSignal;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -17,10 +22,6 @@ use crate::generated_data::sprite_config::SpriteConfig;
 use crate::generated_data::sprite_config::SpriteConfigs;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_signal::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::infra::LogicalSignal;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct SignalLayer;
 
@@ -77,7 +78,7 @@ async fn generate_signaling_system_and_sprite<'a, T: Iterator<Item = &'a String>
             .bind::<Text, _>(signaling_system)
             .bind::<Nullable<Text>, _>(sprite_id)
             .bind::<Array<Text>, _>(signals)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
     }
     Ok(())
@@ -94,7 +95,7 @@ impl GeneratedData for SignalLayer {
 
         sql_query(include_str!("sql/generate_signal_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         generate_signaling_system_and_sprite(
             conn,
@@ -124,7 +125,7 @@ impl GeneratedData for SignalLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(involved_objects.deleted)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -134,7 +135,7 @@ impl GeneratedData for SignalLayer {
             sql_query(include_str!("sql/insert_update_signal_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(&updated_signals)
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
             generate_signaling_system_and_sprite(
                 conn,
diff --git a/editoast/src/generated_data/speed_section.rs b/editoast/src/generated_data/speed_section.rs
index 2a3afa95a2f..d8a8869abe6 100644
--- a/editoast/src/generated_data/speed_section.rs
+++ b/editoast/src/generated_data/speed_section.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use async_trait::async_trait;
 use diesel::delete;
 use diesel::query_dsl::methods::FilterDsl;
@@ -6,6 +8,9 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_speed_section::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +18,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_speed_section::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct SpeedSectionLayer;
 
@@ -28,7 +30,7 @@ impl GeneratedData for SpeedSectionLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_speed_section_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -55,7 +57,7 @@ impl GeneratedData for SpeedSectionLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(objs)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -64,7 +66,7 @@ impl GeneratedData for SpeedSectionLayer {
             sql_query(include_str!("sql/insert_speed_section_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/switch.rs b/editoast/src/generated_data/switch.rs
index bd62fadcf9f..ee83d26ec5a 100644
--- a/editoast/src/generated_data/switch.rs
+++ b/editoast/src/generated_data/switch.rs
@@ -4,14 +4,15 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
+use std::ops::DerefMut;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct SwitchLayer;
 
@@ -24,7 +25,7 @@ impl GeneratedData for SwitchLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_switch_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -46,7 +47,7 @@ impl GeneratedData for SwitchLayer {
             ))
             .bind::<BigInt, _>(infra)
             .bind::<Array<Text>, _>(involved_objects.deleted.into_iter().collect::<Vec<_>>())
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -55,7 +56,7 @@ impl GeneratedData for SwitchLayer {
             sql_query(include_str!("sql/insert_update_switch_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/generated_data/track_section.rs b/editoast/src/generated_data/track_section.rs
index bc1ec627e8f..d6a89d60877 100644
--- a/editoast/src/generated_data/track_section.rs
+++ b/editoast/src/generated_data/track_section.rs
@@ -6,6 +6,10 @@ use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::tables::infra_layer_track_section::dsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectType;
+use std::ops::DerefMut;
 
 use super::utils::InvolvedObjects;
 use super::GeneratedData;
@@ -13,9 +17,6 @@ use crate::diesel::ExpressionMethods;
 use crate::error::Result;
 use crate::infra_cache::operation::CacheOperation;
 use crate::infra_cache::InfraCache;
-use editoast_models::tables::infra_layer_track_section::dsl;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectType;
 
 pub struct TrackSectionLayer;
 
@@ -28,7 +29,7 @@ impl GeneratedData for TrackSectionLayer {
     async fn generate(conn: &mut DbConnection, infra: i64, _cache: &InfraCache) -> Result<()> {
         sql_query(include_str!("sql/generate_track_section_layer.sql"))
             .bind::<BigInt, _>(infra)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -49,7 +50,7 @@ impl GeneratedData for TrackSectionLayer {
                     .filter(dsl::infra_id.eq(infra))
                     .filter(dsl::obj_id.eq_any(involved_objects.deleted)),
             )
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         }
 
@@ -58,7 +59,7 @@ impl GeneratedData for TrackSectionLayer {
             sql_query(include_str!("sql/insert_update_track_section_layer.sql"))
                 .bind::<BigInt, _>(infra)
                 .bind::<Array<Text>, _>(involved_objects.updated.into_iter().collect::<Vec<_>>())
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await?;
         }
         Ok(())
diff --git a/editoast/src/infra_cache/mod.rs b/editoast/src/infra_cache/mod.rs
index e462e59dd5c..de34a5ca773 100644
--- a/editoast/src/infra_cache/mod.rs
+++ b/editoast/src/infra_cache/mod.rs
@@ -43,6 +43,7 @@ use enum_map::EnumMap;
 use geos::geojson::Geometry;
 pub use graph::Graph;
 use itertools::Itertools as _;
+use std::ops::DerefMut;
 use thiserror::Error;
 
 use crate::error::Result;
@@ -436,7 +437,7 @@ impl InfraCache {
             FROM infra_object_track_section WHERE infra_id = $1",
         )
         .bind::<BigInt, _>(infra_id)
-        .load::<TrackQueryable>(conn)
+        .load::<TrackQueryable>(conn.write().await.deref_mut())
         .await?
         .into_iter()
         .try_for_each(|track| infra_cache.add::<TrackSectionCache>(track.into()))?;
@@ -445,7 +446,7 @@ impl InfraCache {
         sql_query(
             "SELECT obj_id, data->>'track' AS track, (data->>'position')::float AS position, data->'logical_signals' as logical_signals FROM infra_object_signal WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
-        .load::<SignalCache>(conn).await?.into_iter().try_for_each(|signal|
+        .load::<SignalCache>(conn.write().await.deref_mut()).await?.into_iter().try_for_each(|signal|
             infra_cache.add(signal)
         )?;
 
@@ -471,7 +472,7 @@ impl InfraCache {
         sql_query(
             "SELECT obj_id, data->>'parts' AS parts FROM infra_object_operational_point WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
-        .load::<OperationalPointQueryable>(conn).await?.into_iter().try_for_each(|op|
+        .load::<OperationalPointQueryable>(&mut conn.write().await).await?.into_iter().try_for_each(|op|
             infra_cache.add::<OperationalPointCache>(op.into())
         )?;
 
@@ -479,12 +480,12 @@ impl InfraCache {
         sql_query(
             "SELECT obj_id, data->>'switch_type' AS switch_type, data->>'ports' AS ports FROM infra_object_switch WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
-        .load::<SwitchQueryable>(conn).await?.into_iter().try_for_each(|switch|
+        .load::<SwitchQueryable>(&mut conn.write().await).await?.into_iter().try_for_each(|switch|
             infra_cache.add::<SwitchCache>(switch.into())
         )?;
 
         // Load switch types references
-        find_all_schemas::<_, Vec<SwitchType>>(conn, infra_id)
+        find_all_schemas::<_, Vec<SwitchType>>(&mut conn.clone(), infra_id)
             .await?
             .into_iter()
             .try_for_each(|switch_type| infra_cache.add::<SwitchType>(switch_type))?;
@@ -500,7 +501,7 @@ impl InfraCache {
         sql_query(
             "SELECT obj_id, data->>'track' AS track, (data->>'position')::float AS position FROM infra_object_detector WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
-        .load::<DetectorCache>(conn).await?.into_iter().try_for_each(|detector|
+        .load::<DetectorCache>(&mut conn.write().await).await?.into_iter().try_for_each(|detector|
             infra_cache.add(detector)
         )?;
 
@@ -508,7 +509,7 @@ impl InfraCache {
         sql_query(
             "SELECT obj_id, data->>'track' AS track, (data->>'position')::float AS position FROM infra_object_buffer_stop WHERE infra_id = $1")
         .bind::<BigInt, _>(infra_id)
-        .load::<BufferStopCache>(conn).await?.into_iter().try_for_each(|buffer_stop|
+        .load::<BufferStopCache>(&mut conn.write().await).await?.into_iter().try_for_each(|buffer_stop|
             infra_cache.add(buffer_stop)
         )?;
 
@@ -533,7 +534,7 @@ impl InfraCache {
             return Ok(infra_cache);
         }
         // Cache miss
-        infra_caches.insert_new(infra.id, InfraCache::load(conn, infra).await?);
+        infra_caches.insert_new(infra.id, InfraCache::load(&mut conn.clone(), infra).await?);
         Ok(infra_caches.get(&infra.id).unwrap())
     }
 
@@ -549,7 +550,7 @@ impl InfraCache {
             return Ok(infra_cache);
         }
         // Cache miss
-        infra_caches.insert_new(infra.id, InfraCache::load(conn, infra).await?);
+        infra_caches.insert_new(infra.id, InfraCache::load(&mut conn.clone(), infra).await?);
         Ok(infra_caches.get_mut(&infra.id).unwrap())
     }
 
@@ -885,7 +886,6 @@ pub mod tests {
     use pretty_assertions::assert_eq;
     use rstest::rstest;
     use std::collections::HashMap;
-    use std::ops::DerefMut;
 
     use super::OperationalPointCache;
     use crate::infra_cache::object_cache::BufferStopCache;
@@ -920,14 +920,10 @@ pub mod tests {
     #[rstest]
     async fn load_track_section() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let track = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            TrackSection::default(),
-        )
-        .await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let track =
+            create_infra_object(&mut db_pool.get_ok(), infra.id, TrackSection::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -938,10 +934,9 @@ pub mod tests {
     #[rstest]
     async fn load_signal() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let signal =
-            create_infra_object(db_pool.get_ok().deref_mut(), infra.id, Signal::default()).await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let signal = create_infra_object(&mut db_pool.get_ok(), infra.id, Signal::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -953,9 +948,9 @@ pub mod tests {
     #[rstest]
     async fn load_speed_section() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let speed = create_infra_object(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             infra.id,
             SpeedSection {
                 track_ranges: vec![Default::default()],
@@ -963,7 +958,7 @@ pub mod tests {
             },
         )
         .await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -975,10 +970,9 @@ pub mod tests {
     #[rstest]
     async fn load_route() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let route =
-            create_infra_object(db_pool.get_ok().deref_mut(), infra.id, Route::default()).await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let route = create_infra_object(&mut db_pool.get_ok(), infra.id, Route::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -988,9 +982,9 @@ pub mod tests {
     #[rstest]
     async fn load_operational_point() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let op = create_infra_object(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             infra.id,
             OperationalPoint {
                 parts: vec![Default::default()],
@@ -999,7 +993,7 @@ pub mod tests {
         )
         .await;
 
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1011,9 +1005,9 @@ pub mod tests {
     #[rstest]
     async fn load_switch() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let switch = create_infra_object(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             infra.id,
             Switch {
                 ports: HashMap::from([("port".into(), Default::default())]),
@@ -1021,7 +1015,7 @@ pub mod tests {
             },
         )
         .await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1031,14 +1025,10 @@ pub mod tests {
     #[rstest]
     async fn load_switch_type() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let s_type = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            SwitchType::default(),
-        )
-        .await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let s_type =
+            create_infra_object(&mut db_pool.get_ok(), infra.id, SwitchType::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1048,10 +1038,10 @@ pub mod tests {
     #[rstest]
     async fn load_detector() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let detector =
-            create_infra_object(db_pool.get_ok().deref_mut(), infra.id, Detector::default()).await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+            create_infra_object(&mut db_pool.get_ok(), infra.id, Detector::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1063,14 +1053,9 @@ pub mod tests {
     #[rstest]
     async fn load_buffer_stop() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let bs = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            BufferStop::default(),
-        )
-        .await;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let bs = create_infra_object(&mut db_pool.get_ok(), infra.id, BufferStop::default()).await;
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1082,9 +1067,9 @@ pub mod tests {
     #[rstest]
     async fn load_electrification() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let electrification = create_infra_object(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             infra.id,
             Electrification {
                 track_ranges: vec![Default::default()],
@@ -1093,7 +1078,7 @@ pub mod tests {
         )
         .await;
 
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &infra)
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &infra)
             .await
             .unwrap();
 
@@ -1387,13 +1372,13 @@ pub mod tests {
     #[rstest]
     async fn load_infra_cache() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let infra_caches = CHashMap::new();
-        InfraCache::get_or_load(db_pool.get_ok().deref_mut(), &infra_caches, &infra)
+        InfraCache::get_or_load(&mut db_pool.get_ok(), &infra_caches, &infra)
             .await
             .unwrap();
         assert_eq!(infra_caches.len(), 1);
-        InfraCache::get_or_load(db_pool.get_ok().deref_mut(), &infra_caches, &infra)
+        InfraCache::get_or_load(&mut db_pool.get_ok(), &infra_caches, &infra)
             .await
             .unwrap();
         assert_eq!(infra_caches.len(), 1);
@@ -1402,13 +1387,13 @@ pub mod tests {
     #[rstest]
     async fn load_infra_cache_mut() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let infra_caches = CHashMap::new();
-        InfraCache::get_or_load_mut(db_pool.get_ok().deref_mut(), &infra_caches, &infra)
+        InfraCache::get_or_load_mut(&mut db_pool.get_ok(), &infra_caches, &infra)
             .await
             .unwrap();
         assert_eq!(infra_caches.len(), 1);
-        InfraCache::get_or_load_mut(db_pool.get_ok().deref_mut(), &infra_caches, &infra)
+        InfraCache::get_or_load_mut(&mut db_pool.get_ok(), &infra_caches, &infra)
             .await
             .unwrap();
         assert_eq!(infra_caches.len(), 1);
diff --git a/editoast/src/infra_cache/operation/create.rs b/editoast/src/infra_cache/operation/create.rs
index 708102ac87b..066f764bac7 100644
--- a/editoast/src/infra_cache/operation/create.rs
+++ b/editoast/src/infra_cache/operation/create.rs
@@ -3,14 +3,15 @@ use diesel::sql_types::BigInt;
 use diesel::sql_types::Json;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
-
-use super::OperationError;
-use crate::error::Result;
-use crate::modelsv2::get_table;
 use editoast_models::DbConnection;
 use editoast_schemas::infra::InfraObject;
 use editoast_schemas::primitives::OSRDIdentified;
 use editoast_schemas::primitives::OSRDObject;
+use std::ops::DerefMut;
+
+use super::OperationError;
+use crate::error::Result;
+use crate::modelsv2::get_table;
 
 pub async fn apply_create_operation<'r>(
     infra_object: &'r InfraObject,
@@ -27,7 +28,7 @@ pub async fn apply_create_operation<'r>(
     .bind::<BigInt, _>(infra_id)
     .bind::<Text, _>(infra_object.get_id())
     .bind::<Json, _>(infra_object.get_data())
-    .execute(conn)
+    .execute(conn.write().await.deref_mut())
     .await
     .map(|idx| (idx, infra_object))
     .map_err(|err| err.into())
@@ -46,7 +47,6 @@ pub mod tests {
     use editoast_schemas::infra::Switch;
     use editoast_schemas::infra::SwitchType;
     use editoast_schemas::infra::TrackSection;
-    use std::ops::DerefMut;
 
     macro_rules! test_create_object {
         ($obj:ident) => {
@@ -54,11 +54,11 @@ pub mod tests {
                 #[rstest::rstest]
                 async fn [<test_create_ $obj:snake>]() {
                     let db_pool = editoast_models::DbConnectionPoolV2::for_tests();
-                    let infra = crate::modelsv2::fixtures::create_empty_infra(db_pool.get_ok().deref_mut()).await;
+                    let infra = crate::modelsv2::fixtures::create_empty_infra(&mut db_pool.get_ok()).await;
                     let infra_object = editoast_schemas::infra::InfraObject::$obj {
                         railjson: $obj::default(),
                     };
-                    let result = crate::infra_cache::operation::create::apply_create_operation(&infra_object, infra.id, db_pool.get_ok().deref_mut()).await;
+                    let result = crate::infra_cache::operation::create::apply_create_operation(&infra_object, infra.id, &mut db_pool.get_ok()).await;
                     assert!(result.is_ok(), "Failed to create a {}", stringify!($obj));
                 }
             }
diff --git a/editoast/src/infra_cache/operation/delete.rs b/editoast/src/infra_cache/operation/delete.rs
index fa1543a5d30..16939dd8739 100644
--- a/editoast/src/infra_cache/operation/delete.rs
+++ b/editoast/src/infra_cache/operation/delete.rs
@@ -2,15 +2,16 @@ use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
+use editoast_schemas::primitives::ObjectRef;
+use editoast_schemas::primitives::ObjectType;
 use serde::Deserialize;
 use serde::Serialize;
+use std::ops::DerefMut;
 
 use super::OperationError;
 use crate::error::Result;
 use crate::modelsv2::get_table;
-use editoast_models::DbConnection;
-use editoast_schemas::primitives::ObjectRef;
-use editoast_schemas::primitives::ObjectType;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, utoipa::ToSchema)]
 #[serde(deny_unknown_fields)]
@@ -28,7 +29,7 @@ impl DeleteOperation {
         ))
         .bind::<Text, _>(&self.obj_id)
         .bind::<BigInt, _>(&infra_id)
-        .execute(conn)
+        .execute(conn.write().await.deref_mut())
         .await
         {
             Ok(1) => Ok(()),
@@ -93,16 +94,16 @@ mod tests {
                     use std::ops::DerefMut;
 
                     let db_pool = DbConnectionPoolV2::for_tests();
-                    let infra = crate::modelsv2::fixtures::create_empty_infra(db_pool.get_ok().deref_mut()).await;
+                    let infra = crate::modelsv2::fixtures::create_empty_infra(&mut db_pool.get_ok()).await;
 
                     let railjson_object = editoast_schemas::infra::InfraObject::$obj {
                         railjson: $obj::default(),
                     };
-                    let result = crate::infra_cache::operation::create::apply_create_operation(&railjson_object, infra.id, db_pool.get_ok().deref_mut()).await;
+                    let result = crate::infra_cache::operation::create::apply_create_operation(&railjson_object, infra.id, &mut db_pool.get_ok()).await;
                     assert!(result.is_ok(), "Failed to create a {}", stringify!($obj));
 
                     let object_deletion: crate::infra_cache::operation::delete::DeleteOperation = railjson_object.get_ref().into();
-                    let result = object_deletion.apply(infra.id, db_pool.get_ok().deref_mut()).await;
+                    let result = object_deletion.apply(infra.id, &mut db_pool.get_ok()).await;
                     assert!(result.is_ok(), "Failed to delete a {}", stringify!($obj));
 
                     let res_del = diesel::sql_query(format!(
@@ -111,7 +112,7 @@ mod tests {
                             railjson_object.get_id(),
                             infra.id
                         ))
-                        .get_result::<Count>(db_pool.get_ok().deref_mut()).await.unwrap();
+                        .get_result::<Count>(&mut db_pool.get_ok().write().await.deref_mut()).await.unwrap();
 
                     pretty_assertions::assert_eq!(res_del.nb, 0);
                 }
diff --git a/editoast/src/infra_cache/operation/update.rs b/editoast/src/infra_cache/operation/update.rs
index 684674f0114..dc2fda85df1 100644
--- a/editoast/src/infra_cache/operation/update.rs
+++ b/editoast/src/infra_cache/operation/update.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use diesel::result::Error as DieselError;
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
@@ -6,6 +8,10 @@ use diesel::sql_types::Jsonb;
 use diesel::sql_types::Text;
 use diesel::QueryableByName;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
+use editoast_schemas::infra::InfraObject;
+use editoast_schemas::primitives::OSRDIdentified;
+use editoast_schemas::primitives::ObjectType;
 use json_patch::Patch;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,10 +22,6 @@ use serde_json::Value;
 use super::OperationError;
 use crate::error::Result;
 use crate::modelsv2::get_table;
-use editoast_models::DbConnection;
-use editoast_schemas::infra::InfraObject;
-use editoast_schemas::primitives::OSRDIdentified;
-use editoast_schemas::primitives::ObjectType;
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, utoipa::ToSchema)]
 #[serde(deny_unknown_fields)]
@@ -40,7 +42,7 @@ impl UpdateOperation {
         ))
         .bind::<BigInt, _>(infra_id)
         .bind::<Text, _>(&self.obj_id)
-        .get_result(conn)
+        .get_result(conn.write().await.deref_mut())
         .await
         {
             Ok(obj) => obj,
@@ -65,7 +67,7 @@ impl UpdateOperation {
         .bind::<Json, _>(obj.data)
         .bind::<BigInt, _>(infra_id)
         .bind::<Text, _>(&self.obj_id)
-        .execute(conn)
+        .execute(conn.write().await.deref_mut())
         .await
         {
             Ok(1) => Ok(railjson_obj),
@@ -157,13 +159,9 @@ mod tests {
     #[rstest]
     async fn valid_update_track() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let track = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            TrackSection::default(),
-        )
-        .await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let track =
+            create_infra_object(&mut db_pool.get_ok(), infra.id, TrackSection::default()).await;
         let update_track = UpdateOperation {
             obj_id: track.get_id().clone(),
             obj_type: ObjectType::TrackSection,
@@ -176,7 +174,7 @@ mod tests {
         };
 
         assert!(update_track
-            .apply(infra.id, db_pool.get_ok().deref_mut())
+            .apply(infra.id, &mut db_pool.get_ok())
             .await
             .is_ok());
 
@@ -185,7 +183,7 @@ mod tests {
                 track.get_id(),
                 infra.id
             ))
-            .get_result::<Value>(db_pool.get_ok().deref_mut()).await.unwrap();
+            .get_result::<Value>(db_pool.get_ok().write().await.deref_mut()).await.unwrap();
 
         assert_eq!(updated_length.val, 80.0);
     }
@@ -193,13 +191,9 @@ mod tests {
     #[rstest]
     async fn invalid_update_track() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let track = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            TrackSection::default(),
-        )
-        .await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let track =
+            create_infra_object(&mut db_pool.get_ok(), infra.id, TrackSection::default()).await;
         let update_track = UpdateOperation {
             obj_id: track.get_id().clone(),
             obj_type: ObjectType::TrackSection,
@@ -210,9 +204,7 @@ mod tests {
             )
             .unwrap(),
         };
-        let res = update_track
-            .apply(infra.id, db_pool.get_ok().deref_mut())
-            .await;
+        let res = update_track.apply(infra.id, &mut db_pool.get_ok()).await;
 
         assert!(res.is_err());
         assert_eq!(
@@ -224,9 +216,8 @@ mod tests {
     #[rstest]
     async fn valid_update_signal() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let signal =
-            create_infra_object(db_pool.get_ok().deref_mut(), infra.id, Signal::default()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let signal = create_infra_object(&mut db_pool.get_ok(), infra.id, Signal::default()).await;
         let update_signal = UpdateOperation {
             obj_id: signal.get_id().clone(),
             obj_type: ObjectType::Signal,
@@ -239,7 +230,7 @@ mod tests {
         };
 
         assert!(update_signal
-            .apply(infra.id, db_pool.get_ok().deref_mut())
+            .apply(infra.id, &mut db_pool.get_ok())
             .await
             .is_ok());
 
@@ -248,7 +239,7 @@ mod tests {
                 signal.get_id(),
                 infra.id
             ))
-            .get_result::<Value>(db_pool.get_ok().deref_mut()).await.unwrap();
+            .get_result::<Value>(db_pool.get_ok().write().await.deref_mut()).await.unwrap();
 
         assert_eq!(updated_length.val, 15.0);
     }
@@ -256,9 +247,8 @@ mod tests {
     #[rstest]
     async fn valid_update_switch_extension() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let switch =
-            create_infra_object(db_pool.get_ok().deref_mut(), infra.id, Switch::default()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let switch = create_infra_object(&mut db_pool.get_ok(), infra.id, Switch::default()).await;
         let update_switch = UpdateOperation {
                 obj_id: switch.get_id().clone(),
                 obj_type: ObjectType::Switch,
@@ -271,7 +261,7 @@ mod tests {
             };
 
         assert!(update_switch
-            .apply(infra.id, db_pool.get_ok().deref_mut())
+            .apply(infra.id, &mut db_pool.get_ok())
             .await
             .is_ok());
 
@@ -280,7 +270,7 @@ mod tests {
                 switch.get_id(),
                 infra.id
             ))
-            .get_result::<Label>(db_pool.get_ok().deref_mut()).await.unwrap();
+            .get_result::<Label>(db_pool.get_ok().write().await.deref_mut()).await.unwrap();
 
         assert_eq!(updated_comment.label, "Switch Label");
     }
@@ -288,13 +278,9 @@ mod tests {
     #[rstest]
     async fn valid_update_speed() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let speed = create_infra_object(
-            db_pool.get_ok().deref_mut(),
-            infra.id,
-            SpeedSection::default(),
-        )
-        .await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
+        let speed =
+            create_infra_object(&mut db_pool.get_ok(), infra.id, SpeedSection::default()).await;
         let update_speed = UpdateOperation {
             obj_id: speed.get_id().clone(),
             obj_type: ObjectType::SpeedSection,
@@ -307,7 +293,7 @@ mod tests {
         };
 
         assert!(update_speed
-            .apply(infra.id, db_pool.get_ok().deref_mut())
+            .apply(infra.id, &mut db_pool.get_ok())
             .await
             .is_ok());
 
@@ -316,7 +302,7 @@ mod tests {
                 speed.get_id(),
                 infra.id
             ))
-            .get_result::<Value>(db_pool.get_ok().deref_mut()).await.unwrap();
+            .get_result::<Value>(db_pool.get_ok().write().await.deref_mut()).await.unwrap();
 
         assert_eq!(updated_speed.val, 80.0);
     }
@@ -324,7 +310,7 @@ mod tests {
     #[rstest]
     async fn wrong_id_update_track() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let update_track = UpdateOperation {
             obj_id: "non_existent_id".to_string(),
             obj_type: ObjectType::TrackSection,
@@ -335,9 +321,7 @@ mod tests {
             )
             .unwrap(),
         };
-        let res = update_track
-            .apply(infra.id, db_pool.get_ok().deref_mut())
-            .await;
+        let res = update_track.apply(infra.id, &mut db_pool.get_ok()).await;
 
         assert!(res.is_err());
         assert_eq!(
diff --git a/editoast/src/main.rs b/editoast/src/main.rs
index 938e985c8c1..44aee1a9e63 100644
--- a/editoast/src/main.rs
+++ b/editoast/src/main.rs
@@ -63,7 +63,6 @@ pub use redis_utils::{RedisClient, RedisConnection};
 use std::error::Error;
 use std::fs::File;
 use std::io::{BufReader, IsTerminal};
-use std::ops::DerefMut;
 use std::path::PathBuf;
 use std::process::exit;
 use std::sync::Arc;
@@ -243,16 +242,16 @@ async fn trains_export(
     args: ExportTimetableArgs,
     db_pool: Arc<DbConnectionPoolV2>,
 ) -> Result<(), Box<dyn Error + Send + Sync>> {
-    let train_ids =
-        match TimetableWithTrains::retrieve(db_pool.get().await?.deref_mut(), args.id).await? {
-            Some(timetable) => timetable.train_ids,
-            None => {
-                let error = CliError::new(1, format!("❌ Timetable not found, id: {0}", args.id));
-                return Err(Box::new(error));
-            }
-        };
+    let train_ids = match TimetableWithTrains::retrieve(&mut db_pool.get().await?, args.id).await? {
+        Some(timetable) => timetable.train_ids,
+        None => {
+            let error = CliError::new(1, format!("❌ Timetable not found, id: {0}", args.id));
+            return Err(Box::new(error));
+        }
+    };
+
     let (train_schedules, missing): (Vec<_>, _) =
-        TrainSchedule::retrieve_batch(db_pool.get().await?.deref_mut(), train_ids).await?;
+        TrainSchedule::retrieve_batch(&mut db_pool.get().await?, train_ids).await?;
 
     assert!(missing.is_empty());
 
@@ -288,16 +287,14 @@ async fn trains_import(
     };
 
     let timetable = match args.id {
-        Some(timetable) => match Timetable::retrieve(db_pool.get().await?.deref_mut(), timetable)
-            .await?
-        {
+        Some(timetable) => match Timetable::retrieve(&mut db_pool.get().await?, timetable).await? {
             Some(timetable) => timetable,
             None => {
                 let error = CliError::new(1, format!("❌ Timetable not found, id: {0}", timetable));
                 return Err(Box::new(error));
             }
         },
-        None => Timetable::create(db_pool.get().await?.deref_mut()).await?,
+        None => Timetable::create(&mut db_pool.get().await?).await?,
     };
 
     let train_schedules: Vec<TrainScheduleBase> =
@@ -313,7 +310,7 @@ async fn trains_import(
         })
         .collect();
     let inserted: Vec<_> =
-        TrainSchedule::create_batch(db_pool.get().await?.deref_mut(), changesets).await?;
+        TrainSchedule::create_batch(&mut db_pool.get().await?, changesets).await?;
 
     println!(
         "✅ {} train schedules created for timetable with id {}",
@@ -514,12 +511,12 @@ async fn generate_infra(
     let mut infras = vec![];
     if args.infra_ids.is_empty() {
         // Retrieve all available infra
-        for infra in Infra::all(db_pool.get().await?.deref_mut()).await {
+        for infra in Infra::all(&mut db_pool.get().await?).await {
             infras.push(infra);
         }
     } else {
         // Retrieve given infras
-        infras = batch_retrieve_infras(db_pool.get().await?.deref_mut(), &args.infra_ids).await?;
+        infras = batch_retrieve_infras(&mut db_pool.get().await?, &args.infra_ids).await?;
     }
     for mut infra in infras {
         println!(
@@ -527,7 +524,7 @@ async fn generate_infra(
             infra.name.clone().bold(),
             infra.id
         );
-        let infra_cache = InfraCache::load(db_pool.get().await?.deref_mut(), &infra).await?;
+        let infra_cache = InfraCache::load(&mut db_pool.get().await?, &infra).await?;
         if infra
             .refresh(db_pool.clone(), args.force, &infra_cache)
             .await?
@@ -571,7 +568,7 @@ async fn import_rolling_stock(
                 let rolling_stock = rolling_stock
                     .locked(false)
                     .version(0)
-                    .create(db_pool.get().await?.deref_mut())
+                    .create(&mut db_pool.get().await?)
                     .await?;
                 println!(
                     "✅ Rolling stock {}[{}] saved!",
@@ -606,7 +603,7 @@ async fn clone_infra(
     infra_args: InfraCloneArgs,
     db_pool: Arc<DbConnectionPoolV2>,
 ) -> Result<(), Box<dyn Error + Send + Sync>> {
-    let infra = Infra::retrieve(db_pool.get().await?.deref_mut(), infra_args.id as i64)
+    let infra = Infra::retrieve(&mut db_pool.get().await?, infra_args.id as i64)
         .await?
         .ok_or_else(|| {
             // When EditoastError will be removed from the models crate,
@@ -619,9 +616,7 @@ async fn clone_infra(
     let new_name = infra_args
         .new_name
         .unwrap_or_else(|| format!("{} (clone)", infra.name));
-    let cloned_infra = infra
-        .clone(db_pool.get().await?.deref_mut(), new_name)
-        .await?;
+    let cloned_infra = infra.clone(&mut db_pool.get().await?, new_name).await?;
     println!(
         "✅ Infra {} (ID: {}) was successfully cloned",
         cloned_infra.name.bold(),
@@ -656,19 +651,17 @@ async fn import_railjson(
     let railjson: RailJson = serde_json::from_reader(BufReader::new(railjson_file))?;
 
     println!("🍞 Importing infra {infra_name}");
-    let mut infra = infra
-        .persist(railjson, db_pool.get().await?.deref_mut())
-        .await?;
+    let mut infra = infra.persist(railjson, &mut db_pool.get().await?).await?;
 
     infra
-        .bump_version(db_pool.get().await?.deref_mut())
+        .bump_version(&mut db_pool.get().await?)
         .await
         .map_err(|_| InfraApiError::NotFound { infra_id: infra.id })?;
 
     println!("✅ Infra {infra_name}[{}] saved!", infra.id);
     // Generate only if the was set
     if args.generate {
-        let infra_cache = InfraCache::load(db_pool.get().await?.deref_mut(), &infra).await?;
+        let infra_cache = InfraCache::load(&mut db_pool.get().await?, &infra).await?;
         infra.refresh(db_pool, true, &infra_cache).await?;
         println!(
             "✅ Infra {infra_name}[{}] generated data refreshed!",
@@ -690,7 +683,7 @@ async fn electrical_profile_set_import(
         .name(args.name)
         .data(electrical_profile_set_data);
 
-    let created_ep_set = ep_set.create(db_pool.get().await?.deref_mut()).await?;
+    let created_ep_set = ep_set.create(&mut db_pool.get().await?).await?;
     println!("✅ Electrical profile set {} created", created_ep_set.id);
     Ok(())
 }
@@ -699,10 +692,9 @@ async fn electrical_profile_set_list(
     args: ListProfileSetArgs,
     db_pool: Arc<DbConnectionPoolV2>,
 ) -> Result<(), Box<dyn Error + Send + Sync>> {
-    let electrical_profile_sets =
-        ElectricalProfileSet::list_light(db_pool.get().await?.deref_mut())
-            .await
-            .unwrap();
+    let electrical_profile_sets = ElectricalProfileSet::list_light(&mut db_pool.get().await?)
+        .await
+        .unwrap();
     if !args.quiet {
         println!("Electrical profile sets:\nID - Name");
     }
@@ -721,7 +713,7 @@ async fn electrical_profile_set_delete(
 ) -> Result<(), Box<dyn Error + Send + Sync>> {
     for profile_set_id in args.profile_set_ids {
         let deleted =
-            ElectricalProfileSet::delete_static(db_pool.get().await?.deref_mut(), profile_set_id)
+            ElectricalProfileSet::delete_static(&mut db_pool.get().await?, profile_set_id)
                 .await
                 .unwrap();
         if !deleted {
@@ -743,12 +735,12 @@ async fn clear_infra(
     let mut infras = vec![];
     if args.infra_ids.is_empty() {
         // Retrieve all available infra
-        for infra in Infra::all(db_pool.get().await?.deref_mut()).await {
+        for infra in Infra::all(&mut db_pool.get().await?).await {
             infras.push(infra);
         }
     } else {
         // Retrieve given infras
-        infras = batch_retrieve_infras(db_pool.get().await?.deref_mut(), &args.infra_ids).await?;
+        infras = batch_retrieve_infras(&mut db_pool.get().await?, &args.infra_ids).await?;
     };
 
     for mut infra in infras {
@@ -758,7 +750,7 @@ async fn clear_infra(
             infra.id
         );
         build_redis_pool_and_invalidate_all_cache(redis_config.clone(), infra.id).await?;
-        infra.clear(db_pool.get().await?.deref_mut()).await?;
+        infra.clear(&mut db_pool.get().await?).await?;
         println!("✅ Infra {}[{}] cleared!", infra.name.bold(), infra.id);
     }
     Ok(())
@@ -868,11 +860,11 @@ async fn refresh_search_tables(
         println!("🤖 Refreshing search table for {}", object);
         println!("🚮 Dropping {} content", search_config.table);
         sql_query(search_config.clear_sql())
-            .execute(db_pool.get().await?.deref_mut())
+            .execute(&mut db_pool.get().await?.write().await)
             .await?;
         println!("♻️  Regenerating {}", search_config.table);
         sql_query(search_config.refresh_table_sql())
-            .execute(db_pool.get().await?.deref_mut())
+            .execute(&mut db_pool.get().await?.write().await)
             .await?;
         println!("✅ Search table for {} refreshed!", object);
     }
@@ -914,7 +906,6 @@ mod tests {
     use rstest::rstest;
     use serde::Serialize;
     use std::io::Write;
-    use std::ops::DerefMut;
     use tempfile::NamedTempFile;
 
     pub fn get_trainschedule_json_array() -> &'static str {
@@ -933,9 +924,7 @@ mod tests {
     async fn import_export_timetable_schedule() {
         let db_pool = DbConnectionPoolV2::for_tests();
 
-        let timetable = Timetable::create(db_pool.get_ok().deref_mut())
-            .await
-            .unwrap();
+        let timetable = Timetable::create(&mut db_pool.get_ok()).await.unwrap();
 
         let mut file = NamedTempFile::new().unwrap();
         file.write_all(get_trainschedule_json_array().as_bytes())
@@ -966,7 +955,7 @@ mod tests {
         let reimport_result = trains_import(reimport_args, db_pool.clone().into()).await;
         assert!(reimport_result.is_ok(), "{:?}", reimport_result);
 
-        Timetable::delete_static(db_pool.get_ok().deref_mut(), timetable.id)
+        Timetable::delete_static(&mut db_pool.get_ok(), timetable.id)
             .await
             .unwrap();
     }
@@ -1009,12 +998,10 @@ mod tests {
             "import should succeed, as raise_panto and startup are not required for non electric",
         );
         use crate::modelsv2::Retrieve;
-        let created_rs = RollingStockModel::retrieve(
-            db_pool.get_ok().deref_mut(),
-            rolling_stock_name.to_string(),
-        )
-        .await
-        .unwrap();
+        let created_rs =
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), rolling_stock_name.to_string())
+                .await
+                .unwrap();
         assert!(created_rs.is_some());
     }
 
@@ -1038,13 +1025,11 @@ mod tests {
         // THEN
         assert!(result.is_ok(), "import should succeed");
         use crate::modelsv2::Retrieve;
-        let created_rs = RollingStockModel::retrieve(
-            db_pool.get_ok().deref_mut(),
-            rolling_stock_name.to_string(),
-        )
-        .await
-        .expect("failed to retrieve rolling stock")
-        .unwrap();
+        let created_rs =
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), rolling_stock_name.to_string())
+                .await
+                .expect("failed to retrieve rolling stock")
+                .unwrap();
         let RollingStockModel {
             electrical_power_startup_time,
             raise_pantograph_time,
@@ -1077,12 +1062,10 @@ mod tests {
             "import should fail, as raise_panto and startup are required for electric"
         );
         use crate::modelsv2::Retrieve;
-        let created_rs = RollingStockModel::retrieve(
-            db_pool.get_ok().deref_mut(),
-            rolling_stock_name.to_string(),
-        )
-        .await
-        .unwrap();
+        let created_rs =
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), rolling_stock_name.to_string())
+                .await
+                .unwrap();
         assert!(created_rs.is_none());
     }
 
@@ -1104,13 +1087,11 @@ mod tests {
         // THEN
         assert!(result.is_ok(), "import should succeed");
         use crate::modelsv2::Retrieve;
-        let created_rs = RollingStockModel::retrieve(
-            db_pool.get_ok().deref_mut(),
-            rolling_stock_name.to_string(),
-        )
-        .await
-        .expect("Failed to retrieve rolling stock")
-        .unwrap();
+        let created_rs =
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), rolling_stock_name.to_string())
+                .await
+                .expect("Failed to retrieve rolling stock")
+                .unwrap();
         let RollingStockModel {
             electrical_power_startup_time,
             raise_pantograph_time,
@@ -1180,8 +1161,7 @@ mod tests {
     async fn test_electrical_profile_set_delete() {
         // GIVEN
         let db_pool = DbConnectionPoolV2::for_tests();
-        let electrical_profile_set =
-            create_electrical_profile_set(db_pool.get_ok().deref_mut()).await;
+        let electrical_profile_set = create_electrical_profile_set(&mut db_pool.get_ok()).await;
 
         let args = DeleteProfileSetArgs {
             profile_set_ids: vec![electrical_profile_set.id],
@@ -1193,7 +1173,7 @@ mod tests {
             .unwrap();
 
         // THEN
-        let empty = !ElectricalProfileSet::list_light(db_pool.get_ok().deref_mut())
+        let empty = !ElectricalProfileSet::list_light(&mut db_pool.get_ok())
             .await
             .unwrap()
             .iter()
@@ -1204,7 +1184,7 @@ mod tests {
     #[rstest]
     async fn test_electrical_profile_set_list_doesnt_fail() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let _ = create_electrical_profile_set(db_pool.get_ok().deref_mut()).await;
+        let _ = create_electrical_profile_set(&mut db_pool.get_ok()).await;
         for quiet in [true, false] {
             let args = ListProfileSetArgs { quiet };
             electrical_profile_set_list(args, db_pool.clone().into())
diff --git a/editoast/src/modelsv2/auth.rs b/editoast/src/modelsv2/auth.rs
index de1e75d4db7..0cee80a0528 100644
--- a/editoast/src/modelsv2/auth.rs
+++ b/editoast/src/modelsv2/auth.rs
@@ -1,7 +1,9 @@
-use std::{collections::HashSet, sync::Arc};
+use std::collections::HashSet;
+use std::ops::DerefMut;
+use std::sync::Arc;
 
 use diesel::{dsl, prelude::*};
-use diesel_async::{scoped_futures::ScopedFutureExt, AsyncConnection, RunQueryDsl};
+use diesel_async::{scoped_futures::ScopedFutureExt, RunQueryDsl};
 use editoast_authz::{
     authorizer::{StorageDriver, UserInfo},
     roles::{BuiltinRoleSet, RoleConfig},
@@ -39,49 +41,49 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
 
     #[tracing::instrument(skip_all, fields(%user), ret, err)]
     async fn ensure_user(&self, user: &UserInfo) -> Result<i64, Self::Error> {
-        let pool = self.pool.clone();
-        let mut conn = pool.get().await?;
-
-        conn.transaction(|conn| {
-            async {
-                let user_id = authn_user::table
-                    .select(authn_user::id)
-                    .filter(authn_user::identity_id.eq(&user.identity))
-                    .first::<i64>(conn)
-                    .await
-                    .optional()?;
-
-                match user_id {
-                    Some(user_id) => {
-                        tracing::debug!("user already exists in db");
-                        Ok(user_id)
-                    }
-
-                    None => {
-                        tracing::info!("registering new user in db");
-
-                        let id: i64 = dsl::insert_into(authn_subject::table)
-                            .default_values()
-                            .returning(authn_subject::id)
-                            .get_result(conn)
-                            .await?;
-
-                        dsl::insert_into(authn_user::table)
-                            .values((
-                                authn_user::id.eq(id),
-                                authn_user::identity_id.eq(&user.identity),
-                                authn_user::name.eq(&user.name),
-                            ))
-                            .execute(conn)
-                            .await?;
-
-                        Ok(id)
+        self.pool
+            .get()
+            .await?
+            .transaction(|conn| {
+                async move {
+                    let user_id = authn_user::table
+                        .select(authn_user::id)
+                        .filter(authn_user::identity_id.eq(&user.identity))
+                        .first::<i64>(conn.write().await.deref_mut())
+                        .await
+                        .optional()?;
+
+                    match user_id {
+                        Some(user_id) => {
+                            tracing::debug!("user already exists in db");
+                            Ok(user_id)
+                        }
+
+                        None => {
+                            tracing::info!("registering new user in db");
+
+                            let id: i64 = dsl::insert_into(authn_subject::table)
+                                .default_values()
+                                .returning(authn_subject::id)
+                                .get_result(&mut conn.clone().write().await)
+                                .await?;
+
+                            dsl::insert_into(authn_user::table)
+                                .values((
+                                    authn_user::id.eq(id),
+                                    authn_user::identity_id.eq(&user.identity),
+                                    authn_user::name.eq(&user.name),
+                                ))
+                                .execute(conn.write().await.deref_mut())
+                                .await?;
+
+                            Ok(id)
+                        }
                     }
                 }
-            }
-            .scope_boxed()
-        })
-        .await
+                .scope_boxed()
+            })
+            .await
     }
 
     #[tracing::instrument(skip_all, fields(%subject_id, %roles_config), ret, err)]
@@ -90,7 +92,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
         subject_id: i64,
         roles_config: &RoleConfig<Self::BuiltinRole>,
     ) -> Result<HashSet<Self::BuiltinRole>, Self::Error> {
-        let mut conn = self.pool.get().await?;
+        let conn = self.pool.get().await?;
 
         let roles = authz_role::table
             .select(authz_role::role)
@@ -99,7 +101,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
             )
             .filter(authz_role::subject.eq(subject_id))
             .or_filter(authz_role::subject.eq(authn_group_membership::group))
-            .load::<String>(&mut conn)
+            .load::<String>(conn.write().await.deref_mut())
             .await?
             .into_iter()
             .map(|role| {
@@ -119,7 +121,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
         roles_config: &RoleConfig<Self::BuiltinRole>,
         roles: HashSet<Self::BuiltinRole>,
     ) -> Result<(), Self::Error> {
-        let mut conn = self.pool.get().await?;
+        let conn = self.pool.get().await?;
 
         dsl::insert_into(authz_role::table)
             .values(
@@ -135,7 +137,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
             )
             .on_conflict((authz_role::subject, authz_role::role))
             .do_nothing()
-            .execute(&mut conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
 
         Ok(())
@@ -148,7 +150,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
         roles_config: &RoleConfig<Self::BuiltinRole>,
         roles: HashSet<Self::BuiltinRole>,
     ) -> Result<HashSet<Self::BuiltinRole>, Self::Error> {
-        let mut conn = self.pool.get().await?;
+        let conn = self.pool.get().await?;
 
         let deleted_roles = dsl::delete(
             authz_role::table
@@ -158,7 +160,7 @@ impl<B: BuiltinRoleSet + Send + Sync> StorageDriver for PgAuthDriver<B> {
                 ),
         )
         .returning(authz_role::role)
-        .load::<String>(&mut conn)
+        .load::<String>(conn.write().await.deref_mut())
         .await?
         .into_iter()
         .map(|role| {
diff --git a/editoast/src/modelsv2/electrical_profiles.rs b/editoast/src/modelsv2/electrical_profiles.rs
index 7d93d404709..9c9701b5dff 100644
--- a/editoast/src/modelsv2/electrical_profiles.rs
+++ b/editoast/src/modelsv2/electrical_profiles.rs
@@ -1,14 +1,16 @@
+use std::ops::DerefMut;
+
 use diesel_async::RunQueryDsl;
 use editoast_derive::ModelV2;
+use editoast_models::tables::electrical_profile_set;
+use editoast_models::DbConnection;
+use editoast_schemas::infra::ElectricalProfileSetData;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
 use crate::diesel::QueryDsl;
 use crate::error::Result;
-use editoast_models::tables::electrical_profile_set;
-use editoast_models::DbConnection;
-use editoast_schemas::infra::ElectricalProfileSetData;
 
 #[derive(Clone, Debug, Serialize, Deserialize, ModelV2, ToSchema)]
 #[model(table = editoast_models::tables::electrical_profile_set)]
@@ -24,7 +26,10 @@ pub struct ElectricalProfileSet {
 impl ElectricalProfileSet {
     pub async fn list_light(conn: &mut DbConnection) -> Result<Vec<LightElectricalProfileSet>> {
         use editoast_models::tables::electrical_profile_set::dsl::*;
-        let result = electrical_profile_set.select((id, name)).load(conn).await?;
+        let result = electrical_profile_set
+            .select((id, name))
+            .load(conn.write().await.deref_mut())
+            .await?;
         Ok(result)
     }
 }
@@ -39,7 +44,6 @@ pub struct LightElectricalProfileSet {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::fixtures::create_electrical_profile_set;
@@ -48,10 +52,10 @@ mod tests {
     #[rstest]
     async fn test_list_light() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let set_1 = create_electrical_profile_set(db_pool.get_ok().deref_mut()).await;
-        let set_2 = create_electrical_profile_set(db_pool.get_ok().deref_mut()).await;
+        let set_1 = create_electrical_profile_set(&mut db_pool.get_ok()).await;
+        let set_2 = create_electrical_profile_set(&mut db_pool.get_ok()).await;
 
-        let list = ElectricalProfileSet::list_light(db_pool.get_ok().deref_mut())
+        let list = ElectricalProfileSet::list_light(&mut db_pool.get_ok())
             .await
             .expect("Failed to list electrical profile sets");
 
diff --git a/editoast/src/modelsv2/fixtures.rs b/editoast/src/modelsv2/fixtures.rs
index d90809ba655..6651e77f5a8 100644
--- a/editoast/src/modelsv2/fixtures.rs
+++ b/editoast/src/modelsv2/fixtures.rs
@@ -1,16 +1,20 @@
 use std::io::Cursor;
+use std::ops::DerefMut;
 
 use chrono::Utc;
+use editoast_models::DbConnection;
+use editoast_models::DbConnectionPool;
+use editoast_models::DbConnectionPoolV2;
 use editoast_schemas::infra::Direction;
 use editoast_schemas::infra::DirectionalTrackRange;
 use editoast_schemas::infra::InfraObject;
 use editoast_schemas::infra::RailJson;
 use editoast_schemas::primitives::OSRDObject;
+use editoast_schemas::rolling_stock::RollingStock;
 use editoast_schemas::train_schedule::TrainScheduleBase;
 use postgis_diesel::types::LineString;
 
 use crate::infra_cache::operation::create::apply_create_operation;
-
 use crate::modelsv2::prelude::*;
 use crate::modelsv2::rolling_stock_livery::RollingStockLiveryModel;
 use crate::modelsv2::timetable::Timetable;
@@ -26,9 +30,6 @@ use crate::modelsv2::Tags;
 use crate::views::rolling_stock::form::RollingStockForm;
 use crate::views::train_schedule::TrainScheduleForm;
 use crate::ElectricalProfileSet;
-use editoast_models::DbConnection;
-use editoast_models::DbConnectionPool;
-use editoast_models::DbConnectionPoolV2;
 
 pub fn project_changeset(name: &str) -> Changeset<Project> {
     Project::changeset()
@@ -193,9 +194,6 @@ pub fn rolling_stock_livery_changeset(
     rolling_stock_id: i64,
     compound_image_id: i64,
 ) -> Changeset<RollingStockLiveryModel> {
-    // let rolling_stock = named_fast_rolling_stock(&rs_name, db_pool.clone()).await;
-    // let image = document_example(db_pool.clone()).await;
-
     RollingStockLiveryModel::changeset()
         .name(name.to_string())
         .rolling_stock_id(rolling_stock_id)
diff --git a/editoast/src/modelsv2/infra.rs b/editoast/src/modelsv2/infra.rs
index 7a4b7c84131..7f0e365f6fc 100644
--- a/editoast/src/modelsv2/infra.rs
+++ b/editoast/src/modelsv2/infra.rs
@@ -16,7 +16,6 @@ use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::ExpressionMethods;
 use diesel::QueryDsl;
-use diesel_async::AsyncConnection;
 use diesel_async::RunQueryDsl;
 use editoast_derive::ModelV2;
 use serde::Deserialize;
@@ -98,7 +97,7 @@ impl InfraChangeset {
 impl Infra {
     pub async fn all(conn: &mut DbConnection) -> Vec<Infra> {
         dsl::infra
-            .load(conn)
+            .load(conn.write().await.deref_mut())
             .await
             .expect("List infra query failed")
             .into_iter()
@@ -122,20 +121,20 @@ impl Infra {
     }
 
     pub async fn clone(&self, conn: &mut DbConnection, new_name: String) -> Result<Infra> {
-        conn.transaction(|conn| Box::pin(async {
+        conn.clone().transaction(|conn| Box::pin(async move {
             // Duplicate infra shell
             let cloned_infra = <Self as Clone>::clone(self)
                 .into_changeset()
                 .name(new_name)
                 .created(Utc::now().naive_utc())
                 .modified(Utc::now().naive_utc())
-                .create(conn)
+                .create(&mut conn.clone())
                 .await?;
 
             // Disable triggers to speed up the cloning
-            sql_query("ALTER TABLE infra_object_signal DISABLE TRIGGER search_signal__ins_trig").execute(conn).await?;
-            sql_query("ALTER TABLE infra_object_track_section DISABLE TRIGGER search_track__ins_trig").execute(conn).await?;
-            sql_query("ALTER TABLE infra_object_operational_point DISABLE TRIGGER search_operational_point__ins_trig").execute(conn).await?;
+            sql_query("ALTER TABLE infra_object_signal DISABLE TRIGGER search_signal__ins_trig").execute(conn.write().await.deref_mut()).await?;
+            sql_query("ALTER TABLE infra_object_track_section DISABLE TRIGGER search_track__ins_trig").execute(conn.write().await.deref_mut()).await?;
+            sql_query("ALTER TABLE infra_object_operational_point DISABLE TRIGGER search_operational_point__ins_trig").execute(conn.write().await.deref_mut()).await?;
 
             // Fill cloned infra with data
             for object in ObjectType::iter() {
@@ -145,7 +144,7 @@ impl Infra {
                 ))
                 .bind::<BigInt, _>(cloned_infra.id)
                 .bind::<BigInt, _>(self.id)
-                .execute(conn).await?;
+                .execute(conn.write().await.deref_mut()).await?;
 
                 if let Some(layer_table) = get_geometry_layer_table(&object) {
                     let layer_table = layer_table.to_string();
@@ -159,15 +158,15 @@ impl Infra {
                     sql_query(sql)
                         .bind::<BigInt, _>(cloned_infra.id)
                         .bind::<BigInt, _>(self.id)
-                        .execute(conn)
+                        .execute(conn.write().await.deref_mut())
                         .await?;
                 }
             }
 
             // Re-enable triggers to speed up the cloning
-            sql_query("ALTER TABLE infra_object_signal ENABLE TRIGGER search_signal__ins_trig").execute(conn).await?;
-            sql_query("ALTER TABLE infra_object_track_section ENABLE TRIGGER search_track__ins_trig").execute(conn).await?;
-            sql_query("ALTER TABLE infra_object_operational_point ENABLE TRIGGER search_operational_point__ins_trig").execute(conn).await?;
+            sql_query("ALTER TABLE infra_object_signal ENABLE TRIGGER search_signal__ins_trig").execute(conn.write().await.deref_mut()).await?;
+            sql_query("ALTER TABLE infra_object_track_section ENABLE TRIGGER search_track__ins_trig").execute(conn.write().await.deref_mut()).await?;
+            sql_query("ALTER TABLE infra_object_operational_point ENABLE TRIGGER search_operational_point__ins_trig").execute(conn.write().await.deref_mut()).await?;
 
             // Fill search tables
             sql_query("INSERT INTO search_signal(id, label, line_name, infra_id, obj_id, signaling_systems, settings, line_code)
@@ -176,12 +175,12 @@ impl Infra {
                         WHERE search_signal.infra_id = $2")
                 .bind::<BigInt, _>(cloned_infra.id)
                 .bind::<BigInt, _>(self.id)
-                .execute(conn).await?;
+                .execute(conn.write().await.deref_mut()).await?;
 
             sql_query("INSERT INTO search_track(infra_id, line_code, line_name, unprocessed_line_name) SELECT $1, line_code, line_name, unprocessed_line_name FROM search_track WHERE infra_id = $2")
                 .bind::<BigInt, _>(cloned_infra.id)
                 .bind::<BigInt, _>(self.id)
-                .execute(conn).await?;
+                .execute(conn.write().await.deref_mut()).await?;
 
             sql_query("INSERT INTO search_operational_point(id, infra_id, obj_id, uic, trigram, ci, ch, name)
                         SELECT op.id, $1, op.obj_id, uic, trigram, ci, ch, name FROM search_operational_point
@@ -189,20 +188,20 @@ impl Infra {
                         WHERE search_operational_point.infra_id = $2")
                 .bind::<BigInt, _>(cloned_infra.id)
                 .bind::<BigInt, _>(self.id)
-                .execute(conn).await?;
+                .execute(conn.write().await.deref_mut()).await?;
 
             // Add error layers
             sql_query("INSERT INTO infra_layer_error(geographic, information, infra_id, info_hash) SELECT geographic, information, $1, info_hash FROM infra_layer_error WHERE infra_id = $2")
                 .bind::<BigInt, _>(cloned_infra.id)
                 .bind::<BigInt, _>(self.id)
-                .execute(conn).await?;
+                .execute(conn.write().await.deref_mut()).await?;
 
             // Add sign layers
             for layer_table in ["infra_layer_psl_sign", "infra_layer_neutral_sign"] {
                 sql_query(format!("INSERT INTO {layer_table}(obj_id, geographic, data, infra_id, angle_geo) SELECT obj_id, geographic, data, $1, angle_geo FROM {layer_table} WHERE infra_id = $2"))
                     .bind::<BigInt, _>(cloned_infra.id)
                     .bind::<BigInt, _>(self.id)
-                    .execute(conn).await?;
+                    .execute(conn.write().await.deref_mut()).await?;
             }
 
             Ok(cloned_infra)
@@ -232,7 +231,7 @@ impl Infra {
         generated_data::refresh_all(db_pool.clone(), self.id, infra_cache).await?;
 
         // Update generated infra version
-        self.bump_generated_version(db_pool.get().await?.deref_mut())
+        self.bump_generated_version(&mut db_pool.get().await?)
             .await?;
 
         Ok(true)
@@ -252,42 +251,48 @@ impl Infra {
     /// This disable some triggers to speed up the deletion.
     ///
     /// Note: Everything is done in one transaction for consistency.
-    pub async fn fast_delete_static(conn: &mut DbConnection, infra_id: i64) -> Result<bool> {
+    pub async fn fast_delete_static(conn: DbConnection, infra_id: i64) -> Result<bool> {
         use editoast_models::tables::infra_object_track_section::dsl as track_section_dsl;
         use editoast_models::tables::search_track::dsl as search_track_dsl;
 
-        conn.build_transaction()
-            .run(|conn| Box::pin(async {
+        conn.transaction(|conn| {
+            Box::pin(async move {
                 // Disable the trigger to speed up the deletion
-                sql_query("ALTER TABLE infra_object_track_section DISABLE TRIGGER search_track__del_trig")
-                    .execute(conn)
-                    .await?;
+                sql_query(
+                    "ALTER TABLE infra_object_track_section DISABLE TRIGGER search_track__del_trig",
+                )
+                .execute(conn.write().await.deref_mut())
+                .await?;
                 // Delete the track sections
                 delete(
                     track_section_dsl::infra_object_track_section
                         .filter(track_section_dsl::infra_id.eq(infra_id)),
                 )
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await
                 .expect("Failed to delete from infra_object_track_section");
                 // Delete search track
                 delete(
-                    search_track_dsl::search_track.filter(search_track_dsl::infra_id.eq(infra_id as i32)),
+                    search_track_dsl::search_track
+                        .filter(search_track_dsl::infra_id.eq(infra_id as i32)),
                 )
-                .execute(conn)
+                .execute(conn.write().await.deref_mut())
                 .await
                 .expect("Failed to delete from search_track");
 
                 // Re-Enable the trigger to speed up the deletion
-                sql_query("ALTER TABLE infra_object_track_section ENABLE TRIGGER search_track__del_trig")
-                    .execute(conn)
-                    .await
-                    .expect("Failed to enable trigger");
+                sql_query(
+                    "ALTER TABLE infra_object_track_section ENABLE TRIGGER search_track__del_trig",
+                )
+                .execute(conn.write().await.deref_mut())
+                .await
+                .expect("Failed to enable trigger");
 
                 // Delete the rest of the infra
-                Self::delete_static(conn, infra_id).await
-            }))
-            .await
+                Self::delete_static(&mut conn.clone(), infra_id).await
+            })
+        })
+        .await
     }
 }
 
@@ -309,7 +314,6 @@ pub mod tests {
     use editoast_schemas::primitives::OSRDIdentified;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
     use uuid::Uuid;
 
     use super::Infra;
@@ -324,7 +328,7 @@ pub mod tests {
     #[rstest]
     async fn create_infra() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         assert_eq!(infra.owner, Uuid::nil());
         assert_eq!(infra.railjson_version, RAILJSON_VERSION);
@@ -339,12 +343,12 @@ pub mod tests {
     async fn clone_infra_with_new_name_returns_new_cloned_infra() {
         // GIVEN
         let db_pool = DbConnectionPoolV2::for_tests();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let infra_new_name = "clone_infra_with_new_name_returns_new_cloned_infra".to_string();
 
         // WHEN
         let result = empty_infra
-            .clone(db_pool.get_ok().deref_mut(), infra_new_name.clone())
+            .clone(&mut db_pool.get_ok(), infra_new_name.clone())
             .await
             .expect("could not clone infra");
 
@@ -363,7 +367,7 @@ pub mod tests {
         let res = Infra::changeset()
             .name("test".to_owned())
             .last_railjson_version()
-            .persist(railjson_with_invalid_version, db_pool.get_ok().deref_mut())
+            .persist(railjson_with_invalid_version, &mut db_pool.get_ok())
             .await;
         assert!(res.is_err());
         let expected_error = RailJsonError::UnsupportedVersion {
@@ -399,7 +403,7 @@ pub mod tests {
         let infra = Infra::changeset()
             .name("persist_railjson_ok_infra".to_owned())
             .last_railjson_version()
-            .persist(railjson.clone(), db_pool.get_ok().deref_mut())
+            .persist(railjson.clone(), &mut db_pool.get_ok())
             .await
             .expect("could not persist infra");
 
@@ -414,91 +418,47 @@ pub mod tests {
         let id = infra.id;
 
         assert_eq!(
-            sort::<BufferStop>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<BufferStop>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.buffer_stops)
         );
         assert_eq!(
-            sort::<Route>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<Route>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.routes)
         );
         assert_eq!(
-            sort::<SwitchType>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<SwitchType>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.extended_switch_types)
         );
         assert_eq!(
-            sort::<Switch>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<Switch>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.switches)
         );
         assert_eq!(
-            sort::<TrackSection>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<TrackSection>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.track_sections)
         );
         assert_eq!(
-            sort::<SpeedSection>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<SpeedSection>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.speed_sections)
         );
         assert_eq!(
-            sort::<NeutralSection>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<NeutralSection>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.neutral_sections)
         );
         assert_eq!(
-            sort::<Electrification>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<Electrification>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.electrifications)
         );
         assert_eq!(
-            sort::<Signal>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<Signal>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.signals)
         );
         assert_eq!(
-            sort::<Detector>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<Detector>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.detectors)
         );
         assert_eq!(
-            sort::<OperationalPoint>(
-                find_all_schemas(db_pool.get_ok().deref_mut(), id)
-                    .await
-                    .unwrap()
-            ),
+            sort::<OperationalPoint>(find_all_schemas(&mut db_pool.get_ok(), id).await.unwrap()),
             sort(railjson.operational_points)
         );
     }
diff --git a/editoast/src/modelsv2/infra/object_queryable.rs b/editoast/src/modelsv2/infra/object_queryable.rs
index f1d215fd6f0..59bde240f2f 100644
--- a/editoast/src/modelsv2/infra/object_queryable.rs
+++ b/editoast/src/modelsv2/infra/object_queryable.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
@@ -6,6 +8,7 @@ use diesel::sql_types::Nullable;
 use diesel::sql_types::Text;
 use diesel::QueryableByName;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use editoast_schemas::primitives::ObjectType;
 use serde::Deserialize;
 use serde::Serialize;
@@ -14,7 +17,6 @@ use super::Infra;
 use crate::error::Result;
 use crate::modelsv2::get_geometry_layer_table;
 use crate::modelsv2::get_table;
-use editoast_models::DbConnection;
 
 editoast_common::schemas! {
     ObjectQueryable,
@@ -66,7 +68,7 @@ impl Infra {
         let objects = sql_query(query)
             .bind::<BigInt, _>(self.id)
             .bind::<Array<Text>, _>(object_ids)
-            .load::<ObjectQueryable>(conn)
+            .load::<ObjectQueryable>(conn.write().await.deref_mut())
             .await?;
         Ok(objects)
     }
diff --git a/editoast/src/modelsv2/infra/railjson_data.rs b/editoast/src/modelsv2/infra/railjson_data.rs
index 90457d99261..82a6dbaa4f9 100644
--- a/editoast/src/modelsv2/infra/railjson_data.rs
+++ b/editoast/src/modelsv2/infra/railjson_data.rs
@@ -1,13 +1,15 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use editoast_schemas::primitives::ObjectType;
 
 use super::Infra;
 use crate::error::Result;
 use crate::modelsv2::get_table;
-use editoast_models::DbConnection;
 
 #[derive(QueryableByName, Default)]
 pub struct RailJsonData {
@@ -25,7 +27,7 @@ impl Infra {
         let query = format!("SELECT (x.data)::text AS railjson FROM {table_name} x WHERE x.infra_id = $1 ORDER BY x.obj_id");
         let railjson_data = sql_query(query)
             .bind::<BigInt, _>(infra_id)
-            .load::<RailJsonData>(conn)
+            .load::<RailJsonData>(conn.write().await.deref_mut())
             .await?;
         Ok(railjson_data)
     }
diff --git a/editoast/src/modelsv2/infra/route_from_waypoint_result.rs b/editoast/src/modelsv2/infra/route_from_waypoint_result.rs
index 08a0edb4724..928c1b8dc9d 100644
--- a/editoast/src/modelsv2/infra/route_from_waypoint_result.rs
+++ b/editoast/src/modelsv2/infra/route_from_waypoint_result.rs
@@ -1,12 +1,14 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Bool;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 
 use super::Infra;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 #[derive(QueryableByName)]
 pub struct RouteFromWaypointResult {
@@ -27,7 +29,7 @@ impl Infra {
             .bind::<BigInt, _>(self.id)
             .bind::<Text, _>(&waypoint_id)
             .bind::<Text, _>(waypoint_type)
-            .load::<RouteFromWaypointResult>(conn)
+            .load::<RouteFromWaypointResult>(conn.write().await.deref_mut())
             .await?;
         Ok(routes)
     }
diff --git a/editoast/src/modelsv2/infra/speed_limit_tags.rs b/editoast/src/modelsv2/infra/speed_limit_tags.rs
index 93835460026..d788dd83e49 100644
--- a/editoast/src/modelsv2/infra/speed_limit_tags.rs
+++ b/editoast/src/modelsv2/infra/speed_limit_tags.rs
@@ -1,13 +1,15 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Infra;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 #[derive(QueryableByName, Debug, Clone, Serialize, Deserialize)]
 pub struct SpeedLimitTags {
@@ -23,7 +25,7 @@ impl Infra {
         let query = include_str!("sql/get_speed_limit_tags.sql");
         let speed_limits_tags = sql_query(query)
             .bind::<BigInt, _>(self.id)
-            .load::<SpeedLimitTags>(conn)
+            .load::<SpeedLimitTags>(conn.write().await.deref_mut())
             .await?;
         Ok(speed_limits_tags)
     }
diff --git a/editoast/src/modelsv2/infra/split_track_section_with_data.rs b/editoast/src/modelsv2/infra/split_track_section_with_data.rs
index 71eb96406a2..3a8d60f11d0 100644
--- a/editoast/src/modelsv2/infra/split_track_section_with_data.rs
+++ b/editoast/src/modelsv2/infra/split_track_section_with_data.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Double;
@@ -5,13 +7,13 @@ use diesel::sql_types::Jsonb;
 use diesel::sql_types::Text;
 use diesel::OptionalExtension;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use editoast_schemas::infra::TrackSection;
 use editoast_schemas::primitives::Identifier;
 use serde::Deserialize;
 
 use super::Infra;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 #[derive(QueryableByName, Debug, Clone, Deserialize)]
 pub struct SplitTrackSectionWithData {
@@ -37,7 +39,7 @@ impl Infra {
             .bind::<BigInt, _>(self.id)
             .bind::<Text, _>(track.to_string())
             .bind::<Double, _>(distance_fraction)
-            .get_result::<SplitTrackSectionWithData>(conn)
+            .get_result::<SplitTrackSectionWithData>(conn.write().await.deref_mut())
             .await
             .optional()?;
         Ok(result)
diff --git a/editoast/src/modelsv2/infra/voltage.rs b/editoast/src/modelsv2/infra/voltage.rs
index ec1234a526e..c644c3fbe9d 100644
--- a/editoast/src/modelsv2/infra/voltage.rs
+++ b/editoast/src/modelsv2/infra/voltage.rs
@@ -1,13 +1,15 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Infra;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 #[derive(QueryableByName, Debug, Clone, Serialize, Deserialize)]
 pub struct Voltage {
@@ -28,14 +30,16 @@ impl Infra {
         };
         let voltages = sql_query(query)
             .bind::<BigInt, _>(self.id)
-            .load::<Voltage>(conn)
+            .load::<Voltage>(conn.write().await.deref_mut())
             .await?;
         Ok(voltages)
     }
 
     pub async fn get_all_voltages(conn: &mut DbConnection) -> Result<Vec<Voltage>> {
         let query = include_str!("sql/get_all_voltages_and_modes.sql");
-        let voltages = sql_query(query).load::<Voltage>(conn).await?;
+        let voltages = sql_query(query)
+            .load::<Voltage>(conn.write().await.deref_mut())
+            .await?;
         Ok(voltages)
     }
 }
diff --git a/editoast/src/modelsv2/infra_objects.rs b/editoast/src/modelsv2/infra_objects.rs
index f2494c84d1b..76b25ef712c 100644
--- a/editoast/src/modelsv2/infra_objects.rs
+++ b/editoast/src/modelsv2/infra_objects.rs
@@ -78,7 +78,7 @@ macro_rules! infra_model {
                 use $table::dsl;
                 Ok($table::table
                     .filter(dsl::infra_id.eq(infra_id))
-                    .load_stream(conn)
+                    .load_stream(conn.write().await.deref_mut())
                     .await?
                     .map_ok(Self::from_row)
                     .try_collect::<C>()
@@ -263,7 +263,7 @@ impl OperationalPointModel {
         Ok(sql_query(query)
             .bind::<BigInt, _>(infra_id)
             .bind::<Array<BigInt>, _>(uic)
-            .load(conn)
+            .load(conn.write().await.deref_mut())
             .await?
             .into_iter()
             .map(Self::from_row)
@@ -288,7 +288,7 @@ impl OperationalPointModel {
         Ok(sql_query(query)
             .bind::<BigInt, _>(infra_id)
             .bind::<Array<Text>, _>(trigrams)
-            .load(conn)
+            .load(conn.write().await.deref_mut())
             .await?
             .into_iter()
             .map(Self::from_row)
@@ -306,10 +306,10 @@ mod tests_persist {
                 #[rstest::rstest]
                 async fn [<test_persist_ $obj:snake>]() {
                     let db_pool =  editoast_models::DbConnectionPoolV2::for_tests();
-                    let infra =  crate::modelsv2::fixtures::create_empty_infra(db_pool.get_ok().deref_mut()).await;
+                    let infra =  crate::modelsv2::fixtures::create_empty_infra(&mut db_pool.get_ok()).await;
                     let schemas = (0..10).map(|_| Default::default());
                     let changesets = $obj::from_infra_schemas(infra.id, schemas);
-                    assert!($obj::create_batch::<_, Vec<_>>(db_pool.get_ok().deref_mut(), changesets).await.is_ok());
+                    assert!($obj::create_batch::<_, Vec<_>>(&mut db_pool.get_ok(), changesets).await.is_ok());
                 }
             }
         };
@@ -340,11 +340,11 @@ mod tests_retrieve {
     #[rstest]
     async fn from_trigrams() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
 
         let trigrams = vec!["MES".to_string(), "WS".to_string()];
         let res = OperationalPointModel::retrieve_from_trigrams(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             small_infra.id,
             &trigrams,
         )
@@ -357,15 +357,12 @@ mod tests_retrieve {
     #[rstest]
     async fn from_uic() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let uic = vec![1, 2];
-        let res = OperationalPointModel::retrieve_from_uic(
-            db_pool.get_ok().deref_mut(),
-            small_infra.id,
-            &uic,
-        )
-        .await
-        .expect("Failed to retrieve operational points");
+        let res =
+            OperationalPointModel::retrieve_from_uic(&mut db_pool.get_ok(), small_infra.id, &uic)
+                .await
+                .expect("Failed to retrieve operational points");
 
         assert_eq!(res.len(), 2);
     }
diff --git a/editoast/src/modelsv2/layers/geo_json_and_data.rs b/editoast/src/modelsv2/layers/geo_json_and_data.rs
index fd4e8bf7113..f794b5b5ae2 100644
--- a/editoast/src/modelsv2/layers/geo_json_and_data.rs
+++ b/editoast/src/modelsv2/layers/geo_json_and_data.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::Integer;
 use diesel::sql_types::Jsonb;
@@ -40,7 +42,7 @@ impl GeoJsonAndData {
             .bind::<Integer, _>(x as i32)
             .bind::<Integer, _>(y as i32)
             .bind::<Integer, _>(infra as i32)
-            .get_results::<GeoJsonAndData>(conn)
+            .get_results::<GeoJsonAndData>(conn.write().await.deref_mut())
             .await?;
 
         Ok(records)
diff --git a/editoast/src/modelsv2/mod.rs b/editoast/src/modelsv2/mod.rs
index 71aca405c36..a3bb1622aad 100644
--- a/editoast/src/modelsv2/mod.rs
+++ b/editoast/src/modelsv2/mod.rs
@@ -45,7 +45,6 @@ editoast_common::schemas! {
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;
-    use std::ops::DerefMut;
 
     use editoast_derive::ModelV2;
     use editoast_models::DbConnectionPoolV2;
@@ -74,7 +73,7 @@ mod tests {
                 .data(vec![i])
         });
 
-        let docs = Document::create_batch::<_, Vec<_>>(pool.get_ok().deref_mut(), changesets)
+        let docs = Document::create_batch::<_, Vec<_>>(&mut pool.get_ok(), changesets)
             .await
             .expect("Failed to create documents");
         assert_eq!(docs.len(), 5);
@@ -83,7 +82,7 @@ mod tests {
         ids.push(123456789);
 
         let (docs, missing): (Vec<_>, _) =
-            Document::retrieve_batch(pool.get_ok().deref_mut(), ids.clone())
+            Document::retrieve_batch(&mut pool.get_ok(), ids.clone())
                 .await
                 .unwrap();
 
@@ -105,17 +104,16 @@ mod tests {
         let new_ct = String::from("I like trains");
         let (updated_docs, missing): (Vec<_>, _) = Document::changeset()
             .content_type(new_ct.clone())
-            .update_batch(pool.get_ok().deref_mut(), ids.iter().cloned().take(2))
+            .update_batch(&mut pool.get_ok(), ids.iter().cloned().take(2))
             .await
             .expect("Failed to update documents");
         assert!(missing.is_empty());
         assert!(updated_docs.iter().all(|d| d.content_type == new_ct));
         assert_eq!(updated_docs.len(), 2);
 
-        let (docs, _): (Vec<_>, _) =
-            Document::retrieve_batch(pool.get_ok().deref_mut(), ids.clone())
-                .await
-                .expect("Failed to retrieve documents");
+        let (docs, _): (Vec<_>, _) = Document::retrieve_batch(&mut pool.get_ok(), ids.clone())
+            .await
+            .expect("Failed to retrieve documents");
         assert_eq!(
             docs.iter()
                 .map(|d| d.content_type.clone())
@@ -124,12 +122,12 @@ mod tests {
         );
 
         let not_deleted = ids.remove(0);
-        let count = Document::delete_batch(pool.get_ok().deref_mut(), ids)
+        let count = Document::delete_batch(&mut pool.get_ok(), ids)
             .await
             .expect("Failed to delete documents");
         assert_eq!(count, 4);
 
-        let exists = Document::exists(pool.get_ok().deref_mut(), not_deleted)
+        let exists = Document::exists(&mut pool.get_ok(), not_deleted)
             .await
             .expect("Failed to check if document exists");
 
@@ -175,7 +173,7 @@ mod tests {
 
         let pool = DbConnectionPoolV2::for_tests();
         let docs = Document::create_batch::<_, Vec<_>>(
-            pool.get_ok().deref_mut(),
+            &mut pool.get_ok(),
             [
                 Document::changeset()
                     .content_type(String::from("text/plain"))
@@ -193,7 +191,7 @@ mod tests {
 
         let ids = docs.iter().map(|d| d.id).collect::<Vec<_>>();
         assert_eq!(
-            Document::retrieve(pool.get_ok().deref_mut(), ids[0])
+            Document::retrieve(&mut pool.get_ok(), ids[0])
                 .await
                 .expect("Failed to retrieve document")
                 .expect("Document not found")
@@ -201,7 +199,7 @@ mod tests {
             Data::Prefixed(0x43)
         );
         assert_eq!(
-            Document::retrieve(pool.get_ok().deref_mut(), ids[1])
+            Document::retrieve(&mut pool.get_ok(), ids[1])
                 .await
                 .expect("Failed to retrieve document")
                 .expect("Document not found")
@@ -221,22 +219,21 @@ mod tests {
                 .content_type(multiple_ct.to_string())
                 .data(vec![i])
         });
-        let mut documents =
-            Document::create_batch::<_, Vec<_>>(pool.get_ok().deref_mut(), changesets)
-                .await
-                .expect("Failed to create documents batch");
+        let mut documents = Document::create_batch::<_, Vec<_>>(&mut pool.get_ok(), changesets)
+            .await
+            .expect("Failed to create documents batch");
         let unique_doc_idx = 10;
 
         documents[unique_doc_idx]
             .patch()
             .content_type(unique_ct.to_string())
-            .apply(pool.get_ok().deref_mut())
+            .apply(&mut pool.get_ok())
             .await
             .expect("Failed to update document");
 
         // WHEN
         let (list, multiple_count) = Document::list_and_count(
-            pool.get_ok().deref_mut(),
+            &mut pool.get_ok(),
             SelectionSettings::new()
                 .filter(move || Document::CONTENT_TYPE.eq(multiple_ct.to_string()))
                 .order_by(|| Document::ID.desc())
@@ -246,7 +243,7 @@ mod tests {
         .expect("Failed to list documents with multiple content type");
 
         let (past_unique_ct_index, unique_count) = Document::list_and_count(
-            pool.get_ok().deref_mut(),
+            &mut pool.get_ok(),
             SelectionSettings::new()
                 .filter(move || Document::CONTENT_TYPE.eq(unique_ct.to_string()))
                 .offset(15),
@@ -254,7 +251,7 @@ mod tests {
         .await
         .expect("Failed to list documents with unique content type");
         let (with_unique, unique_count_bis) = Document::list_and_count(
-            pool.get_ok().deref_mut(),
+            &mut pool.get_ok(),
             SelectionSettings::new()
                 .filter(move || Document::CONTENT_TYPE.eq(unique_ct.to_string())),
         )
diff --git a/editoast/src/modelsv2/pagination.rs b/editoast/src/modelsv2/pagination.rs
index f48647626e5..b88d4a3cc67 100644
--- a/editoast/src/modelsv2/pagination.rs
+++ b/editoast/src/modelsv2/pagination.rs
@@ -4,6 +4,7 @@ use diesel::sql_types::{BigInt, Untyped};
 use diesel::{QueryResult, QueryableByName};
 use diesel_async::RunQueryDsl;
 use editoast_models::DbConnection;
+use std::ops::DerefMut;
 
 use crate::error::Result;
 
@@ -40,7 +41,9 @@ where
         offset: ((page - 1) * page_size) as i64,
     };
 
-    let results = query.load::<RowWithCount<T>>(conn).await?;
+    let results = query
+        .load::<RowWithCount<T>>(conn.write().await.deref_mut())
+        .await?;
 
     if results.is_empty() {
         return Ok((vec![], 0));
diff --git a/editoast/src/modelsv2/prelude/create.rs b/editoast/src/modelsv2/prelude/create.rs
index 2106a2e598a..dfa5d583bf9 100644
--- a/editoast/src/modelsv2/prelude/create.rs
+++ b/editoast/src/modelsv2/prelude/create.rs
@@ -1,8 +1,9 @@
 use std::fmt::Debug;
 
+use editoast_models::DbConnection;
+
 use crate::error::EditoastError;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 /// Describes how a [Model](super::Model) can be created in the database
 ///
diff --git a/editoast/src/modelsv2/prelude/delete.rs b/editoast/src/modelsv2/prelude/delete.rs
index a98a40d6c03..489e8c53803 100644
--- a/editoast/src/modelsv2/prelude/delete.rs
+++ b/editoast/src/modelsv2/prelude/delete.rs
@@ -1,6 +1,7 @@
+use editoast_models::DbConnection;
+
 use crate::error::EditoastError;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 /// Describes how a [Model](super::Model) can be deleted from the database
 ///
diff --git a/editoast/src/modelsv2/prelude/retrieve.rs b/editoast/src/modelsv2/prelude/retrieve.rs
index 578142994c4..85a591aac62 100644
--- a/editoast/src/modelsv2/prelude/retrieve.rs
+++ b/editoast/src/modelsv2/prelude/retrieve.rs
@@ -1,8 +1,9 @@
 use std::fmt::Debug;
 
+use editoast_models::DbConnection;
+
 use crate::error::EditoastError;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 /// Describes how a [Model](super::Model) can be retrieved from the database
 ///
diff --git a/editoast/src/modelsv2/prelude/update.rs b/editoast/src/modelsv2/prelude/update.rs
index f75b94849f1..0faf9f3c9ab 100644
--- a/editoast/src/modelsv2/prelude/update.rs
+++ b/editoast/src/modelsv2/prelude/update.rs
@@ -1,11 +1,11 @@
 use std::fmt::Debug;
 
 use diesel::result::Error::NotFound;
+use editoast_models::DbConnection;
 
 use crate::error::EditoastError;
 use crate::error::Result;
 use crate::models::PreferredId;
-use editoast_models::DbConnection;
 
 use super::Model;
 
diff --git a/editoast/src/modelsv2/projects.rs b/editoast/src/modelsv2/projects.rs
index ebbdf9d92c6..0914e5a2f53 100644
--- a/editoast/src/modelsv2/projects.rs
+++ b/editoast/src/modelsv2/projects.rs
@@ -120,7 +120,6 @@ impl Project {
 pub mod test {
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::fixtures::create_project;
@@ -132,18 +131,17 @@ pub mod test {
     async fn project_creation() {
         let db_pool = DbConnectionPoolV2::for_tests();
         let project_name = "test_project_name";
-        let created_project = create_project(db_pool.get_ok().deref_mut(), project_name).await;
+        let created_project = create_project(&mut db_pool.get_ok(), project_name).await;
         assert_eq!(created_project.name, project_name);
     }
 
     #[rstest]
     async fn project_retrieve() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         // Get a project
-        let project = Project::retrieve(db_pool.get_ok().deref_mut(), created_project.id)
+        let project = Project::retrieve(&mut db_pool.get_ok(), created_project.id)
             .await
             .expect("Failed to retrieve project")
             .expect("Project not found");
@@ -154,8 +152,7 @@ pub mod test {
     #[rstest]
     async fn project_update() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let mut created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let mut created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let project_name = "update_name";
         let project_budget = Some(1000);
@@ -165,11 +162,11 @@ pub mod test {
             .patch()
             .name(project_name.to_owned())
             .budget(project_budget)
-            .apply(db_pool.get_ok().deref_mut())
+            .apply(&mut db_pool.get_ok())
             .await
             .expect("Failed to update project");
 
-        let project = Project::retrieve(db_pool.get_ok().deref_mut(), created_project.id)
+        let project = Project::retrieve(&mut db_pool.get_ok(), created_project.id)
             .await
             .expect("Failed to retrieve project")
             .expect("Project not found");
@@ -181,13 +178,11 @@ pub mod test {
     #[rstest]
     async fn sort_project() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let _created_project_1 =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name_1").await;
-        let _created_project_2 =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name_2").await;
+        let _created_project_1 = create_project(&mut db_pool.get_ok(), "test_project_name_1").await;
+        let _created_project_2 = create_project(&mut db_pool.get_ok(), "test_project_name_2").await;
 
         let projects = Project::list(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             SelectionSettings::new().order_by(|| Project::NAME.desc()),
         )
         .await
diff --git a/editoast/src/modelsv2/railjson.rs b/editoast/src/modelsv2/railjson.rs
index 743a99d077a..a80df4da4c9 100644
--- a/editoast/src/modelsv2/railjson.rs
+++ b/editoast/src/modelsv2/railjson.rs
@@ -5,7 +5,6 @@ use editoast_schemas::infra::RAILJSON_VERSION;
 use crate::error::Result;
 use crate::modelsv2::infra_objects::*;
 use crate::modelsv2::prelude::*;
-use diesel_async::AsyncConnection;
 use editoast_models::DbConnection;
 
 #[derive(Debug, thiserror::Error, EditoastError)]
@@ -48,70 +47,71 @@ pub async fn persist_railjson(
     }
 
     connection
+        .clone()
         .transaction(|conn| {
-            Box::pin(async {
+            Box::pin(async move {
                 let _ = TrackSectionModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     TrackSectionModel::from_infra_schemas(infra_id, track_sections),
                 )
                 .await?;
 
                 let _ = BufferStopModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     BufferStopModel::from_infra_schemas(infra_id, buffer_stops),
                 )
                 .await?;
 
                 let _ = ElectrificationModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     ElectrificationModel::from_infra_schemas(infra_id, electrifications),
                 )
                 .await?;
 
                 let _ = DetectorModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     DetectorModel::from_infra_schemas(infra_id, detectors),
                 )
                 .await?;
 
                 let _ = OperationalPointModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     OperationalPointModel::from_infra_schemas(infra_id, operational_points),
                 )
                 .await?;
 
                 let _ = RouteModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     RouteModel::from_infra_schemas(infra_id, routes),
                 )
                 .await?;
 
                 let _ = SignalModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     SignalModel::from_infra_schemas(infra_id, signals),
                 )
                 .await?;
 
                 let _ = SwitchModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     SwitchModel::from_infra_schemas(infra_id, switches),
                 )
                 .await?;
 
                 let _ = SpeedSectionModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     SpeedSectionModel::from_infra_schemas(infra_id, speed_sections),
                 )
                 .await?;
 
                 let _ = SwitchTypeModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     SwitchTypeModel::from_infra_schemas(infra_id, extended_switch_types),
                 )
                 .await?;
 
                 let _ = NeutralSectionModel::create_batch::<_, Vec<_>>(
-                    conn,
+                    &mut conn.clone(),
                     NeutralSectionModel::from_infra_schemas(infra_id, neutral_sections),
                 )
                 .await?;
diff --git a/editoast/src/modelsv2/rolling_stock_livery.rs b/editoast/src/modelsv2/rolling_stock_livery.rs
index 624438364e6..1e40380181f 100644
--- a/editoast/src/modelsv2/rolling_stock_livery.rs
+++ b/editoast/src/modelsv2/rolling_stock_livery.rs
@@ -58,7 +58,6 @@ impl RollingStockLiveryModel {
 #[cfg(test)]
 pub mod tests {
     use rstest::*;
-    use std::ops::DerefMut;
 
     use super::RollingStockLiveryModel;
     use crate::modelsv2::fixtures::create_rolling_stock_livery_fixture;
@@ -71,32 +70,31 @@ pub mod tests {
         let db_pool = DbConnectionPoolV2::for_tests();
 
         let (rs_livery, _, image) =
-            create_rolling_stock_livery_fixture(db_pool.get_ok().deref_mut(), "rs_livery_name")
-                .await;
+            create_rolling_stock_livery_fixture(&mut db_pool.get_ok(), "rs_livery_name").await;
 
         assert!(
-            RollingStockLiveryModel::retrieve(db_pool.get_ok().deref_mut(), rs_livery.id)
+            RollingStockLiveryModel::retrieve(&mut db_pool.get_ok(), rs_livery.id)
                 .await
                 .is_ok()
         );
 
-        assert!(Document::retrieve(db_pool.get_ok().deref_mut(), image.id)
+        assert!(Document::retrieve(&mut db_pool.get_ok(), image.id)
             .await
             .is_ok());
 
         assert!(rs_livery
-            .delete_with_compound_image(db_pool.get_ok().deref_mut())
+            .delete_with_compound_image(&mut db_pool.get_ok())
             .await
             .is_ok());
 
         assert!(
-            RollingStockLiveryModel::retrieve(db_pool.get_ok().deref_mut(), rs_livery.id)
+            RollingStockLiveryModel::retrieve(&mut db_pool.get_ok(), rs_livery.id)
                 .await
                 .expect("Failed to retrieve rolling stock livery")
                 .is_none()
         );
 
-        assert!(Document::retrieve(db_pool.get_ok().deref_mut(), image.id)
+        assert!(Document::retrieve(&mut db_pool.get_ok(), image.id)
             .await
             .expect("Failed to retrieve document")
             .is_none());
diff --git a/editoast/src/modelsv2/rolling_stock_model.rs b/editoast/src/modelsv2/rolling_stock_model.rs
index 67a9cea9a40..d9311cf3804 100644
--- a/editoast/src/modelsv2/rolling_stock_model.rs
+++ b/editoast/src/modelsv2/rolling_stock_model.rs
@@ -201,7 +201,6 @@ impl From<RollingStock> for RollingStockModelChangeset {
 pub mod tests {
     use rstest::*;
     use serde_json::to_value;
-    use std::ops::DerefMut;
 
     use super::RollingStockModel;
     use crate::error::InternalError;
@@ -219,7 +218,7 @@ pub mod tests {
         let rs_name = "fast_rolling_stock_name";
 
         let created_fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+            create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         // GIVEN
         let rs_name_with_energy_sources_name = "other_rolling_stock_update_rolling_stock";
@@ -230,7 +229,7 @@ pub mod tests {
 
         // WHEN
         let updated_rolling_stock = rolling_stock_with_energy_sources
-            .update(db_pool.get_ok().deref_mut(), rolling_stock_id)
+            .update(&mut db_pool.get_ok(), rolling_stock_id)
             .await
             .expect("Failed to update rolling stock")
             .unwrap();
@@ -247,13 +246,13 @@ pub mod tests {
         // Creating the first rolling stock
         let rs_name = "fast_rolling_stock_name";
         let created_fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+            create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         // Creating the second rolling stock
         let rs_name_with_energy_sources_name = "fast_rolling_stock_with_energy_sources_name";
         let created_fast_rolling_stock_with_energy_sources =
             create_rolling_stock_with_energy_sources(
-                db_pool.get_ok().deref_mut(),
+                &mut db_pool.get_ok(),
                 rs_name_with_energy_sources_name,
             )
             .await;
@@ -261,7 +260,7 @@ pub mod tests {
         // WHEN
         let result = created_fast_rolling_stock_with_energy_sources
             .into_changeset()
-            .update(db_pool.get_ok().deref_mut(), created_fast_rolling_stock.id)
+            .update(&mut db_pool.get_ok(), created_fast_rolling_stock.id)
             .await
             .map_err(|e| map_diesel_error(e, rs_name));
 
diff --git a/editoast/src/modelsv2/rolling_stock_model/power_restrictions.rs b/editoast/src/modelsv2/rolling_stock_model/power_restrictions.rs
index 54affb9fd19..dd329a2608d 100644
--- a/editoast/src/modelsv2/rolling_stock_model/power_restrictions.rs
+++ b/editoast/src/modelsv2/rolling_stock_model/power_restrictions.rs
@@ -1,13 +1,15 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
 use super::RollingStockModel;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 editoast_common::schemas! {
     PowerRestriction,
@@ -22,7 +24,7 @@ pub struct PowerRestriction {
 impl RollingStockModel {
     pub async fn get_power_restrictions(conn: &mut DbConnection) -> Result<Vec<PowerRestriction>> {
         let power_restrictions = sql_query(include_str!("sql/get_power_restrictions.sql"))
-            .load::<PowerRestriction>(conn)
+            .load::<PowerRestriction>(conn.write().await.deref_mut())
             .await?;
         Ok(power_restrictions)
     }
diff --git a/editoast/src/modelsv2/rolling_stock_model/rolling_stock_usage.rs b/editoast/src/modelsv2/rolling_stock_model/rolling_stock_usage.rs
index 2c07aed2ca3..eed7530c62f 100644
--- a/editoast/src/modelsv2/rolling_stock_model/rolling_stock_usage.rs
+++ b/editoast/src/modelsv2/rolling_stock_model/rolling_stock_usage.rs
@@ -1,14 +1,16 @@
+use std::ops::DerefMut;
+
 use diesel::sql_query;
 use diesel::sql_types::BigInt;
 use diesel::sql_types::Text;
 use diesel_async::RunQueryDsl;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
 use super::RollingStockModel;
 use crate::error::Result;
-use editoast_models::DbConnection;
 
 editoast_common::schemas! {
     TrainScheduleScenarioStudyProject,
@@ -41,7 +43,7 @@ impl RollingStockModel {
     ) -> Result<Vec<TrainScheduleScenarioStudyProject>> {
         let result = sql_query(include_str!("sql/get_train_schedules_with_scenario.sql"))
             .bind::<BigInt, _>(self.id)
-            .load::<TrainScheduleScenarioStudyProject>(conn)
+            .load::<TrainScheduleScenarioStudyProject>(conn.write().await.deref_mut())
             .await?;
         Ok(result)
     }
diff --git a/editoast/src/modelsv2/rolling_stock_model/schedules_from_rolling_stock.rs b/editoast/src/modelsv2/rolling_stock_model/schedules_from_rolling_stock.rs
index 4b7bbd97eb1..6f349b2db71 100644
--- a/editoast/src/modelsv2/rolling_stock_model/schedules_from_rolling_stock.rs
+++ b/editoast/src/modelsv2/rolling_stock_model/schedules_from_rolling_stock.rs
@@ -1,3 +1,5 @@
+use std::ops::DerefMut;
+
 use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
 use itertools::Itertools;
@@ -8,8 +10,8 @@ use utoipa::ToSchema;
 
 use crate::error::Result;
 use crate::modelsv2::rolling_stock_model::RollingStockModel;
-use editoast_models::db_connection_pool::DbConnectionV2;
 use editoast_models::tables::{project, rolling_stock, scenario, study, train_schedule};
+use editoast_models::DbConnection;
 
 #[derive(Debug, Serialize, ToSchema)]
 #[cfg_attr(test, derive(PartialEq, Eq, PartialOrd, Ord, Deserialize))]
@@ -39,7 +41,7 @@ impl From<SchedulesFromRollingStock> for ScenarioReference {
 type SchedulesFromRollingStock = (i64, String, i64, String, i64, String);
 
 impl RollingStockModel {
-    pub async fn get_usage(&self, conn: &mut DbConnectionV2) -> Result<Vec<ScenarioReference>> {
+    pub async fn get_usage(&self, conn: &mut DbConnection) -> Result<Vec<ScenarioReference>> {
         let schedules: Vec<_> = train_schedule::table
             .inner_join(
                 rolling_stock::table.on(train_schedule::rolling_stock_name.eq(rolling_stock::name)),
@@ -58,7 +60,7 @@ impl RollingStockModel {
             ))
             .filter(rolling_stock::id.eq(self.id))
             .filter(train_schedule::id.is_not_null())
-            .load::<SchedulesFromRollingStock>(conn)
+            .load::<SchedulesFromRollingStock>(conn.write().await.deref_mut())
             .await?;
         let schedules = schedules.into_iter().map_into().collect();
         Ok(schedules)
diff --git a/editoast/src/modelsv2/scenario.rs b/editoast/src/modelsv2/scenario.rs
index 5514c5df6f5..5749d4984de 100644
--- a/editoast/src/modelsv2/scenario.rs
+++ b/editoast/src/modelsv2/scenario.rs
@@ -1,15 +1,17 @@
+use std::ops::DerefMut;
+
 use chrono::NaiveDateTime;
 use diesel::ExpressionMethods;
 use diesel::QueryDsl;
 use diesel_async::RunQueryDsl;
 use editoast_derive::ModelV2;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
 
 use crate::error::Result;
 use crate::modelsv2::Tags;
-use editoast_models::DbConnection;
 
 #[derive(Debug, Clone, ModelV2, Deserialize, Serialize, ToSchema)]
 #[model(table = editoast_models::tables::scenario)]
@@ -37,7 +39,7 @@ impl Scenario {
         let infra_name = infra_dsl::infra
             .filter(infra_dsl::id.eq(self.infra_id))
             .select(infra_dsl::name)
-            .first::<String>(conn)
+            .first::<String>(conn.write().await.deref_mut())
             .await?;
         Ok(infra_name)
     }
@@ -47,7 +49,7 @@ impl Scenario {
         let trains_count = train_schedule
             .filter(timetable_id.eq(self.timetable_id))
             .count()
-            .get_result(conn)
+            .get_result(conn.write().await.deref_mut())
             .await?;
         Ok(trains_count)
     }
diff --git a/editoast/src/modelsv2/stdcm_search_environment.rs b/editoast/src/modelsv2/stdcm_search_environment.rs
index 87e4eac4879..994c7a379d6 100644
--- a/editoast/src/modelsv2/stdcm_search_environment.rs
+++ b/editoast/src/modelsv2/stdcm_search_environment.rs
@@ -2,13 +2,14 @@ use chrono::NaiveDateTime;
 use diesel::ExpressionMethods;
 use diesel::QueryDsl;
 use diesel_async::RunQueryDsl;
+use editoast_derive::ModelV2;
+use editoast_models::DbConnection;
 use serde::Serialize;
+use std::ops::DerefMut;
 use utoipa::ToSchema;
 
 use crate::error::Result;
 use crate::modelsv2::prelude::{Create, Row};
-use editoast_derive::ModelV2;
-use editoast_models::DbConnection;
 
 #[cfg(test)]
 use serde::Deserialize;
@@ -37,7 +38,7 @@ impl StdcmSearchEnvironment {
         use editoast_models::tables::stdcm_search_environment::dsl::*;
         stdcm_search_environment
             .order_by((search_window_end.desc(), search_window_begin.asc()))
-            .first::<Row<StdcmSearchEnvironment>>(conn)
+            .first::<Row<StdcmSearchEnvironment>>(conn.write().await.deref_mut())
             .await
             .map(Into::into)
             .ok()
@@ -46,7 +47,7 @@ impl StdcmSearchEnvironment {
     pub async fn delete_all(conn: &mut DbConnection) -> Result<()> {
         use editoast_models::tables::stdcm_search_environment::dsl::*;
         diesel::delete(stdcm_search_environment)
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await?;
         Ok(())
     }
@@ -64,7 +65,6 @@ pub mod test {
     use chrono::NaiveDate;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::electrical_profiles::ElectricalProfileSet;
@@ -98,11 +98,11 @@ pub mod test {
     async fn test_overwrite() {
         let db_pool = DbConnectionPoolV2::for_tests();
         let initial_env_count =
-            StdcmSearchEnvironment::count(db_pool.get_ok().deref_mut(), Default::default())
+            StdcmSearchEnvironment::count(&mut db_pool.get_ok(), Default::default())
                 .await
                 .expect("failed to count STDCM envs");
         let (infra, timetable, work_schedule_group, electrical_profile_set) =
-            stdcm_search_env_fixtures(db_pool.get_ok().deref_mut()).await;
+            stdcm_search_env_fixtures(&mut db_pool.get_ok()).await;
 
         let changeset_1 = StdcmSearchEnvironment::changeset()
             .infra_id(infra.id)
@@ -121,30 +121,30 @@ pub mod test {
             .search_window_end(end);
 
         changeset_1
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .expect("Failed to create first search environment");
 
         assert_eq!(
-            StdcmSearchEnvironment::count(db_pool.get_ok().deref_mut(), SelectionSettings::new())
+            StdcmSearchEnvironment::count(&mut db_pool.get_ok(), SelectionSettings::new())
                 .await
                 .expect("Failed to count"),
             initial_env_count + 1
         );
 
         let _ = changeset_2
-            .overwrite(db_pool.get_ok().deref_mut())
+            .overwrite(&mut db_pool.get_ok())
             .await
             .expect("Failed to overwrite search environment");
 
         assert_eq!(
-            StdcmSearchEnvironment::count(db_pool.get_ok().deref_mut(), SelectionSettings::new())
+            StdcmSearchEnvironment::count(&mut db_pool.get_ok(), SelectionSettings::new())
                 .await
                 .expect("Failed to count"),
             1
         );
 
-        let result = StdcmSearchEnvironment::retrieve_latest(db_pool.get_ok().deref_mut())
+        let result = StdcmSearchEnvironment::retrieve_latest(&mut db_pool.get_ok())
             .await
             .expect("Failed to retrieve latest search environment");
 
@@ -155,11 +155,11 @@ pub mod test {
     #[rstest]
     async fn test_retrieve_latest() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        StdcmSearchEnvironment::delete_all(db_pool.get_ok().deref_mut())
+        StdcmSearchEnvironment::delete_all(&mut db_pool.get_ok())
             .await
             .expect("failed to delete envs");
         let (infra, timetable, work_schedule_group, electrical_profile_set) =
-            stdcm_search_env_fixtures(db_pool.get_ok().deref_mut()).await;
+            stdcm_search_env_fixtures(&mut db_pool.get_ok()).await;
 
         let too_old = StdcmSearchEnvironment::changeset()
             .infra_id(infra.id)
@@ -184,12 +184,12 @@ pub mod test {
 
         for changeset in [too_old, too_young.clone(), the_best, too_young] {
             changeset
-                .create(db_pool.get_ok().deref_mut())
+                .create(&mut db_pool.get_ok())
                 .await
                 .expect("Failed to create search environment");
         }
 
-        let result = StdcmSearchEnvironment::retrieve_latest(db_pool.get_ok().deref_mut())
+        let result = StdcmSearchEnvironment::retrieve_latest(&mut db_pool.get_ok())
             .await
             .expect("Failed to retrieve latest search environment");
 
@@ -200,10 +200,10 @@ pub mod test {
     #[rstest]
     async fn test_retrieve_latest_empty() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        StdcmSearchEnvironment::delete_all(db_pool.get_ok().deref_mut())
+        StdcmSearchEnvironment::delete_all(&mut db_pool.get_ok())
             .await
             .expect("failed to delete envs");
-        let result = StdcmSearchEnvironment::retrieve_latest(db_pool.get_ok().deref_mut()).await;
+        let result = StdcmSearchEnvironment::retrieve_latest(&mut db_pool.get_ok()).await;
         assert_eq!(result, None);
     }
 }
diff --git a/editoast/src/modelsv2/study.rs b/editoast/src/modelsv2/study.rs
index e88da6b3623..41aa94d186f 100644
--- a/editoast/src/modelsv2/study.rs
+++ b/editoast/src/modelsv2/study.rs
@@ -3,6 +3,7 @@ use chrono::NaiveDateTime;
 use chrono::Utc;
 
 use editoast_derive::ModelV2;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::ToSchema;
@@ -11,7 +12,6 @@ use crate::error::Result;
 use crate::modelsv2::prelude::*;
 use crate::modelsv2::projects::Tags;
 use crate::modelsv2::Scenario;
-use editoast_models::DbConnection;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ModelV2, ToSchema)]
 #[model(table = editoast_models::tables::study)]
@@ -76,7 +76,6 @@ fn dates_in_order(a: Option<Option<NaiveDate>>, b: Option<Option<NaiveDate>>) ->
 pub mod test {
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::fixtures::create_project;
@@ -86,15 +85,14 @@ pub mod test {
     #[rstest]
     async fn study_retrieve() {
         let db_pool = DbConnectionPoolV2::for_tests();
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let study_name = "test_study_name";
         let created_study =
-            create_study(db_pool.get_ok().deref_mut(), study_name, created_project.id).await;
+            create_study(&mut db_pool.get_ok(), study_name, created_project.id).await;
 
         // Retrieve a study
-        let study = Study::retrieve(db_pool.get_ok().deref_mut(), created_study.id)
+        let study = Study::retrieve(&mut db_pool.get_ok(), created_study.id)
             .await
             .expect("Failed to retrieve study")
             .expect("Study not found");
@@ -106,25 +104,24 @@ pub mod test {
     async fn sort_study() {
         let db_pool = DbConnectionPoolV2::for_tests();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let _created_study_1 = create_study(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             "test_study_name_1",
             created_project.id,
         )
         .await;
 
         let _created_study_2 = create_study(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             "test_study_name_2",
             created_project.id,
         )
         .await;
 
         let studies = Study::list(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             SelectionSettings::new().order_by(|| Study::NAME.desc()),
         )
         .await
diff --git a/editoast/src/modelsv2/timetable.rs b/editoast/src/modelsv2/timetable.rs
index 45a246432d9..abe74d89975 100644
--- a/editoast/src/modelsv2/timetable.rs
+++ b/editoast/src/modelsv2/timetable.rs
@@ -3,6 +3,7 @@ use diesel::sql_query;
 use diesel::sql_types::Array;
 use diesel::sql_types::BigInt;
 use diesel_async::RunQueryDsl;
+use std::ops::DerefMut;
 
 use crate::error::Result;
 use crate::models::Identifiable;
@@ -23,7 +24,7 @@ impl Timetable {
     pub async fn create(conn: &mut DbConnection) -> Result<Self> {
         diesel::insert_into(editoast_models::tables::timetable::table)
             .default_values()
-            .get_result::<Timetable>(conn)
+            .get_result::<Timetable>(conn.write().await.deref_mut())
             .await
             .map(Into::into)
             .map_err(Into::into)
@@ -36,7 +37,7 @@ impl DeleteStatic<i64> for Timetable {
     #[tracing::instrument(name = "model:delete_static<Timetable>", skip_all, ret, err)]
     async fn delete_static(conn: &mut DbConnection, id: i64) -> Result<bool> {
         diesel::delete(dsl::timetable.filter(dsl::id.eq(id)))
-            .execute(conn)
+            .execute(conn.write().await.deref_mut())
             .await
             .map(|n| n == 1)
             .map_err(Into::into)
@@ -53,7 +54,7 @@ impl Retrieve<i64> for Timetable {
     ) -> crate::error::Result<Option<Timetable>> {
         dsl::timetable
             .filter(dsl::id.eq(id))
-            .first::<Timetable>(conn)
+            .first::<Timetable>(conn.write().await.deref_mut())
             .await
             .optional()
             .map_err(Into::into)
@@ -99,7 +100,7 @@ impl Retrieve<i64> for TimetableWithTrains {
         GROUP BY timetable.id",
         )
         .bind::<BigInt, _>(timetable_id)
-        .get_result::<TimetableWithTrains>(conn)
+        .get_result::<TimetableWithTrains>(conn.write().await.deref_mut())
         .await;
         match result {
             Ok(result) => Ok(Some(result)),
diff --git a/editoast/src/views/documents.rs b/editoast/src/views/documents.rs
index 576322c6280..ae70a712fe8 100644
--- a/editoast/src/views/documents.rs
+++ b/editoast/src/views/documents.rs
@@ -167,7 +167,6 @@ mod tests {
     use axum::http::StatusCode;
     use rstest::rstest;
     use serde::Deserialize;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::views::test_app::TestAppBuilder;
@@ -196,7 +195,7 @@ mod tests {
         let new_doc = response.json::<PostDocumentResponse>().document_key;
 
         // Get create document
-        let document = Document::retrieve(pool.get_ok().deref_mut(), new_doc)
+        let document = Document::retrieve(&mut pool.get_ok(), new_doc)
             .await
             .expect("Failed to retrieve document")
             .expect("Document not found");
@@ -213,7 +212,7 @@ mod tests {
         let document = Document::changeset()
             .data(b"Document post test data".to_vec())
             .content_type(String::from("text/plain"))
-            .create(pool.get_ok().deref_mut())
+            .create(&mut pool.get_ok())
             .await
             .expect("Failed to create document");
 
@@ -234,7 +233,7 @@ mod tests {
         let document = Document::changeset()
             .data(b"Document post test data".to_vec())
             .content_type(String::from("text/plain"))
-            .create(pool.get_ok().deref_mut())
+            .create(&mut pool.get_ok())
             .await
             .expect("Failed to create document");
 
@@ -245,7 +244,7 @@ mod tests {
         response.assert_status(StatusCode::NO_CONTENT);
 
         // Get create document
-        let document = Document::exists(pool.get_ok().deref_mut(), document.id)
+        let document = Document::exists(&mut pool.get_ok(), document.id)
             .await
             .expect("Failed to retrieve document");
 
diff --git a/editoast/src/views/electrical_profiles.rs b/editoast/src/views/electrical_profiles.rs
index 817dce04098..9f1a25963c4 100644
--- a/editoast/src/views/electrical_profiles.rs
+++ b/editoast/src/views/electrical_profiles.rs
@@ -225,7 +225,6 @@ mod tests {
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::fixtures::create_electrical_profile_set;
@@ -239,8 +238,8 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let _set_1 = create_electrical_profile_set(pool.get_ok().deref_mut()).await;
-        let _set_2 = create_electrical_profile_set(pool.get_ok().deref_mut()).await;
+        let _set_1 = create_electrical_profile_set(&mut pool.get_ok()).await;
+        let _set_2 = create_electrical_profile_set(&mut pool.get_ok()).await;
 
         let response = app.get("/electrical_profile_set").await;
         response.assert_status(StatusCode::OK);
@@ -262,7 +261,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let electrical_profile_set = create_electrical_profile_set(pool.get_ok().deref_mut()).await;
+        let electrical_profile_set = create_electrical_profile_set(&mut pool.get_ok()).await;
 
         let response = app
             .get(&format!(
@@ -286,7 +285,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let electrical_profile_set = create_electrical_profile_set(pool.get_ok().deref_mut()).await;
+        let electrical_profile_set = create_electrical_profile_set(&mut pool.get_ok()).await;
 
         let response = app
             .get(&format!(
@@ -316,7 +315,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let electrical_profile_set = create_electrical_profile_set(pool.get_ok().deref_mut()).await;
+        let electrical_profile_set = create_electrical_profile_set(&mut pool.get_ok()).await;
 
         let response = app
             .delete(&format!(
@@ -326,10 +325,9 @@ mod tests {
             .await;
         response.assert_status(StatusCode::NO_CONTENT);
 
-        let exists =
-            ElectricalProfileSet::exists(pool.get_ok().deref_mut(), electrical_profile_set.id)
-                .await
-                .expect("Failed to check if electrical profile set exists");
+        let exists = ElectricalProfileSet::exists(&mut pool.get_ok(), electrical_profile_set.id)
+            .await
+            .expect("Failed to check if electrical profile set exists");
 
         assert!(!exists);
     }
@@ -355,7 +353,7 @@ mod tests {
         response.assert_status(StatusCode::OK);
         let created_ep: ElectricalProfileSet = response.json();
 
-        let created_ep = ElectricalProfileSet::retrieve(pool.get_ok().deref_mut(), created_ep.id)
+        let created_ep = ElectricalProfileSet::retrieve(&mut pool.get_ok(), created_ep.id)
             .await
             .expect("Failed to retrieve created electrical profile set")
             .expect("Electrical profile set not found");
diff --git a/editoast/src/views/infra/attached.rs b/editoast/src/views/infra/attached.rs
index 2bb0ad80f9a..dafdee65b15 100644
--- a/editoast/src/views/infra/attached.rs
+++ b/editoast/src/views/infra/attached.rs
@@ -115,7 +115,6 @@ mod tests {
     use std::collections::HashMap;
 
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use crate::infra_cache::operation::create::apply_create_operation;
     use crate::modelsv2::prelude::*;
@@ -135,13 +134,13 @@ mod tests {
         let empty_infra = Infra::changeset()
             .name("test_infra".to_owned())
             .last_railjson_version()
-            .create(pool.get_ok().deref_mut())
+            .create(&mut pool.get_ok())
             .await
             .expect("Failed to create infra");
 
         // Create a track and a detector on it
         let track = TrackSection::default().into();
-        apply_create_operation(&track, empty_infra.id, pool.get_ok().deref_mut())
+        apply_create_operation(&track, empty_infra.id, &mut pool.get_ok())
             .await
             .expect("Failed to create track object");
 
@@ -150,7 +149,7 @@ mod tests {
             ..Default::default()
         }
         .into();
-        apply_create_operation(&detector, empty_infra.id, pool.get_ok().deref_mut())
+        apply_create_operation(&detector, empty_infra.id, &mut pool.get_ok())
             .await
             .expect("Failed to create detector object");
 
diff --git a/editoast/src/views/infra/auto_fixes/mod.rs b/editoast/src/views/infra/auto_fixes/mod.rs
index 1268a0398f3..0208cc7f6cc 100644
--- a/editoast/src/views/infra/auto_fixes/mod.rs
+++ b/editoast/src/views/infra/auto_fixes/mod.rs
@@ -1,6 +1,5 @@
 use std::collections::hash_map::Entry;
 use std::collections::hash_map::HashMap;
-use std::ops::DerefMut;
 
 use axum::extract::Json;
 use axum::extract::Path;
@@ -101,16 +100,15 @@ async fn list_auto_fixes(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
-        InfraApiError::NotFound { infra_id }
-    })
-    .await?;
+    let conn = &mut db_pool.get().await?;
+
+    let infra =
+        Infra::retrieve_or_fail(conn, infra_id, || InfraApiError::NotFound { infra_id }).await?;
 
     // accepting the early release of ReadGuard as it's anyway released when sending the suggestions (so before edit)
-    let mut infra_cache_clone =
-        InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra)
-            .await?
-            .clone();
+    let mut infra_cache_clone = InfraCache::get_or_load(conn, &infra_caches, &infra)
+        .await?
+        .clone();
 
     let mut fixes = vec![];
     for _ in 0..MAX_AUTO_FIXES_ITERATIONS {
@@ -335,7 +333,6 @@ mod tests {
     use editoast_schemas::infra::BufferStop;
     use editoast_schemas::infra::BufferStopExtension;
     use pretty_assertions::assert_eq;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::generated_data::infra_error::InfraErrorType;
@@ -380,7 +377,7 @@ mod tests {
     async fn test_no_fix() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let small_infra_id = small_infra.id;
 
         let operations: Vec<Operation> = app
@@ -396,9 +393,9 @@ mod tests {
         // GIVEN
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let mut small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let mut small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let small_infra_id = small_infra.id;
-        let mut infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &small_infra)
+        let mut infra_cache = InfraCache::load(&mut db_pool.get_ok(), &small_infra)
             .await
             .expect("Failed to get infra cache");
         small_infra
@@ -408,7 +405,7 @@ mod tests {
 
         // Check the only initial issues are "overlapping_speed_sections" warnings
         let (infra_errors_before_all, before_all_count) =
-            query_errors(db_pool.get_ok().deref_mut(), &small_infra).await;
+            query_errors(&mut db_pool.get_ok(), &small_infra).await;
         assert!(infra_errors_before_all
             .iter()
             .all(|e| matches!(e.sub_type, InfraErrorType::OverlappingSpeedSections { .. })));
@@ -420,7 +417,7 @@ mod tests {
         };
         let deletion = Operation::Delete(delete_operation.clone());
         let _ = deletion
-            .apply(small_infra_id, db_pool.get_ok().deref_mut())
+            .apply(small_infra_id, &mut db_pool.get_ok())
             .await
             .expect("Failed to delete a track");
         infra_cache
@@ -433,7 +430,7 @@ mod tests {
 
         // Check that some new issues appeared
         let (infra_errors_before_fix, before_fix_count) =
-            query_errors(db_pool.get_ok().deref_mut(), &small_infra).await;
+            query_errors(&mut db_pool.get_ok(), &small_infra).await;
         assert!(before_fix_count > before_all_count);
 
         // WHEN
@@ -443,8 +440,7 @@ mod tests {
             .json_into();
 
         // THEN
-        let (infra_errors_after_fix, _) =
-            query_errors(db_pool.get_ok().deref_mut(), &small_infra).await;
+        let (infra_errors_after_fix, _) = query_errors(&mut db_pool.get_ok(), &small_infra).await;
         assert_eq!(infra_errors_after_fix, infra_errors_before_fix);
 
         assert!(operations.contains(&Operation::Delete(DeleteOperation {
@@ -469,7 +465,7 @@ mod tests {
     async fn test_fix_invalid_ref_route_entry_exit() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let small_infra_id = small_infra.id;
         // Remove a buffer stop
         let deletion = Operation::Delete(DeleteOperation {
@@ -477,7 +473,7 @@ mod tests {
             obj_type: ObjectType::BufferStop,
         });
         deletion
-            .apply(small_infra_id, db_pool.get_ok().deref_mut())
+            .apply(small_infra_id, &mut db_pool.get_ok())
             .await
             .expect("Failed to delete BufferStop");
 
@@ -702,7 +698,7 @@ mod tests {
     async fn invalid_switch_ports() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let small_infra_id = small_infra.id;
 
         let ports = HashMap::from([
@@ -719,7 +715,7 @@ mod tests {
         apply_create_operation(
             &invalid_switch.clone().into(),
             small_infra_id,
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
         )
         .await
         .expect("Failed to create invalid_switch object");
@@ -739,7 +735,7 @@ mod tests {
     async fn odd_buffer_stop_location() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         // Create an odd buffer stops (to a track endpoint linked by a switch)
@@ -771,7 +767,7 @@ mod tests {
         }
         .into();
         for obj in [&track, &bs_start, &bs_stop, &bs_odd] {
-            apply_create_operation(obj, empty_infra_id, db_pool.get_ok().deref_mut())
+            apply_create_operation(obj, empty_infra_id, &mut db_pool.get_ok())
                 .await
                 .expect("Failed to create object");
         }
@@ -791,7 +787,7 @@ mod tests {
     async fn empty_object() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         let electrification: InfraObject = Electrification::default().into();
@@ -799,7 +795,7 @@ mod tests {
         let speed_section = SpeedSection::default().into();
 
         for obj in [&electrification, &operational_point, &speed_section] {
-            apply_create_operation(obj, empty_infra_id, db_pool.get_ok().deref_mut())
+            apply_create_operation(obj, empty_infra_id, &mut db_pool.get_ok())
                 .await
                 .expect("Failed to create object");
         }
@@ -821,7 +817,7 @@ mod tests {
     async fn out_of_range_must_be_ignored() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         let track: InfraObject = TrackSection {
@@ -869,7 +865,7 @@ mod tests {
         .into();
 
         for obj in [&track, &electrification, &operational_point, &speed_section] {
-            apply_create_operation(obj, empty_infra_id, db_pool.get_ok().deref_mut())
+            apply_create_operation(obj, empty_infra_id, &mut db_pool.get_ok())
                 .await
                 .expect("Failed to create object");
         }
@@ -893,7 +889,7 @@ mod tests {
     async fn out_of_range_must_be_deleted(#[case] pos: f64, #[case] error_count: usize) {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         let track: InfraObject = TrackSection {
@@ -929,7 +925,7 @@ mod tests {
         .into();
 
         for obj in [&track, &signal, &detector, &buffer_stop] {
-            apply_create_operation(obj, empty_infra_id, db_pool.get_ok().deref_mut())
+            apply_create_operation(obj, empty_infra_id, &mut db_pool.get_ok())
                 .await
                 .expect("Failed to create object");
         }
@@ -956,7 +952,7 @@ mod tests {
         // GIVEN
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         let track: InfraObject = TrackSection {
@@ -965,7 +961,7 @@ mod tests {
             ..Default::default()
         }
         .into();
-        apply_create_operation(&track, empty_infra_id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&track, empty_infra_id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create track section object");
 
diff --git a/editoast/src/views/infra/edition.rs b/editoast/src/views/infra/edition.rs
index 617b668bf77..f5ffa43bd1d 100644
--- a/editoast/src/views/infra/edition.rs
+++ b/editoast/src/views/infra/edition.rs
@@ -2,7 +2,6 @@ use axum::extract::Json;
 use axum::extract::Path;
 use axum::extract::State;
 use axum::Extension;
-use diesel_async::AsyncConnection;
 use editoast_authz::BuiltinRole;
 use editoast_derive::EditoastError;
 use editoast_schemas::infra::ApplicableDirectionsTrackRange;
@@ -20,7 +19,6 @@ use itertools::Itertools;
 use json_patch::{AddOperation, Patch, PatchOperation, RemoveOperation, ReplaceOperation};
 use serde_json::json;
 use std::collections::HashMap;
-use std::ops::DerefMut;
 use thiserror::Error;
 use tracing::error;
 use tracing::info;
@@ -91,15 +89,14 @@ async fn edit<'a>(
     }
 
     // TODO: lock for update
-    let mut infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let mut infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
     let mut infra_cache =
-        InfraCache::get_or_load_mut(db_pool.get().await?.deref_mut(), &infra_caches, &infra)
-            .await?;
+        InfraCache::get_or_load_mut(&mut db_pool.get().await?, &infra_caches, &infra).await?;
     let operation_results = apply_edit(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         &mut infra,
         &operations,
         &mut infra_cache,
@@ -153,13 +150,12 @@ pub async fn split_track_section<'a>(
     );
 
     // Check the infra
-    let mut infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let mut infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
     let mut infra_cache =
-        InfraCache::get_or_load_mut(db_pool.get().await?.deref_mut(), &infra_caches, &infra)
-            .await?;
+        InfraCache::get_or_load_mut(&mut db_pool.get().await?, &infra_caches, &infra).await?;
 
     // Get tracks cache if it exists
     let tracksection_cached = infra_cache.get_track_section(&payload.track)?.clone();
@@ -179,7 +175,7 @@ pub async fn split_track_section<'a>(
     // Calling the DB to get the full object and also the split geo
     let result = infra
         .get_split_track_section_with_data(
-            db_pool.get().await?.deref_mut(),
+            &mut db_pool.get().await?,
             payload.track.clone(),
             distance_fraction,
         )
@@ -332,7 +328,7 @@ pub async fn split_track_section<'a>(
 
     // Apply operations
     apply_edit(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         &mut infra,
         &operations,
         &mut infra_cache,
@@ -854,12 +850,13 @@ async fn apply_edit(
 
     // Apply modifications in one transaction
     connection
+        .clone()
         .transaction(|conn| {
-            Box::pin(async {
+            Box::pin(async move {
                 let mut railjsons = vec![];
                 let mut cache_operations = vec![];
                 for operation in operations {
-                    let railjson = operation.apply(infra_id, conn).await?;
+                    let railjson = operation.apply(infra_id, &mut conn.clone()).await?;
                     match (operation, railjson) {
                         (Operation::Create(_), Some(railjson)) => {
                             railjsons.push(railjson.clone());
@@ -880,17 +877,22 @@ async fn apply_edit(
                 }
 
                 // Bump version
-                infra.bump_version(conn).await?;
+                infra.bump_version(&mut conn.clone()).await?;
                 // Apply operations to infra cache
                 infra_cache.apply_operations(&cache_operations)?;
 
                 // Refresh layers if needed
-                generated_data::update_all(conn, infra_id, &cache_operations, infra_cache)
-                    .await
-                    .expect("Update generated data failed");
+                generated_data::update_all(
+                    &mut conn.clone(),
+                    infra_id,
+                    &cache_operations,
+                    infra_cache,
+                )
+                .await
+                .expect("Update generated data failed");
 
                 // Bump infra generated version to the infra version
-                infra.bump_generated_version(conn).await?;
+                infra.bump_generated_version(&mut conn.clone()).await?;
 
                 Ok(railjsons)
             })
@@ -949,7 +951,7 @@ pub mod tests {
         // Init
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
 
         // Make a call with a bad ID
         let request = app
@@ -968,7 +970,7 @@ pub mod tests {
         // Init
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
 
         // Make a call with a bad distance
         let request = app
@@ -989,7 +991,7 @@ pub mod tests {
         // Init
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
 
         // Refresh the infra to get the good number of infra errors
         let req_refresh =
@@ -997,7 +999,7 @@ pub mod tests {
         app.fetch(req_refresh).assert_status(StatusCode::OK);
 
         // Get infra errors
-        let (init_errors, _) = query_errors(db_pool.get_ok().deref_mut(), &small_infra).await;
+        let (init_errors, _) = query_errors(&mut db_pool.get_ok(), &small_infra).await;
 
         // Make a call to split the track section
         let request = app
@@ -1012,7 +1014,7 @@ pub mod tests {
         assert_eq!(res.len(), 2);
 
         // Check that infra errors has not increased with the split (omit route error for now)
-        let (errors, _) = query_errors(db_pool.get_ok().deref_mut(), &small_infra).await;
+        let (errors, _) = query_errors(&mut db_pool.get_ok(), &small_infra).await;
         let errors_without_routes: Vec<InfraError> = errors
             .into_iter()
             .filter(|e| {
@@ -1031,8 +1033,11 @@ pub mod tests {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
         let conn = &mut db_pool.get().await.unwrap();
-        let mut small_infra = create_small_infra(conn).await;
-        let mut infra_cache = InfraCache::load(conn, &small_infra).await.unwrap();
+
+        let mut small_infra = create_small_infra(&mut db_pool.get_ok()).await;
+        let mut infra_cache = InfraCache::load(&mut db_pool.get_ok(), &small_infra)
+            .await
+            .unwrap();
 
         // Calling "apply_edit" with a OK operation
         let operations: Vec<Operation> = [
diff --git a/editoast/src/views/infra/errors.rs b/editoast/src/views/infra/errors.rs
index eba32c08f7a..379999b5b53 100644
--- a/editoast/src/views/infra/errors.rs
+++ b/editoast/src/views/infra/errors.rs
@@ -138,7 +138,6 @@ pub(in crate::views) async fn query_errors(
 mod tests {
     use axum::http::StatusCode;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use crate::modelsv2::fixtures::create_empty_infra;
     use crate::views::test_app::TestAppBuilder;
@@ -147,7 +146,7 @@ mod tests {
     async fn list_errors_get() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let error_type = "overlapping_electrifications";
         let level = "warnings";
diff --git a/editoast/src/views/infra/lines.rs b/editoast/src/views/infra/lines.rs
index b3f8685295c..f44143bb183 100644
--- a/editoast/src/views/infra/lines.rs
+++ b/editoast/src/views/infra/lines.rs
@@ -90,7 +90,6 @@ mod test {
     use pretty_assertions::assert_eq;
     use rstest::rstest;
     use serde_json::json;
-    use std::ops::DerefMut;
     use std::str::FromStr;
 
     use crate::infra_cache::operation::create::apply_create_operation;
@@ -104,7 +103,7 @@ mod test {
     async fn returns_correct_bbox_for_existing_line_code() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let line_code = 1234;
         let geometry_json = json!({
@@ -125,7 +124,7 @@ mod test {
             ..Default::default()
         }
         .into();
-        apply_create_operation(&track_section, empty_infra.id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&track_section, empty_infra.id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create track section object");
 
@@ -140,7 +139,7 @@ mod test {
     async fn returns_bad_request_when_line_code_not_found() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let not_existing_line_code = 123456789;
         let request = app.get(
diff --git a/editoast/src/views/infra/mod.rs b/editoast/src/views/infra/mod.rs
index eb002fea86d..805407705e2 100644
--- a/editoast/src/views/infra/mod.rs
+++ b/editoast/src/views/infra/mod.rs
@@ -20,7 +20,6 @@ use editoast_derive::EditoastError;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
-use std::ops::DerefMut;
 use thiserror::Error;
 use utoipa::IntoParams;
 use utoipa::ToSchema;
@@ -146,10 +145,10 @@ async fn refresh(
 
     let infras_list = if infras.is_empty() {
         // Retrieve all available infra
-        Infra::all(db_pool.get().await?.deref_mut()).await
+        Infra::all(&mut db_pool.get().await?).await
     } else {
         // Retrieve given infras
-        Infra::retrieve_batch_or_fail(db_pool.get().await?.deref_mut(), infras, |missing| {
+        Infra::retrieve_batch_or_fail(&mut db_pool.get().await?, infras, |missing| {
             InfraApiError::NotFound {
                 infra_id: missing.into_iter().next().unwrap(),
             }
@@ -163,8 +162,7 @@ async fn refresh(
 
     for mut infra in infras_list {
         let infra_cache =
-            InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra)
-                .await?;
+            InfraCache::get_or_load(&mut db_pool.get().await?, &infra_caches, &infra).await?;
         if infra.refresh(db_pool.clone(), force, &infra_cache).await? {
             infra_refreshed.push(infra.id);
         }
@@ -298,7 +296,7 @@ async fn get(
     let core_client = app_state.core_client.clone();
 
     let infra_id = infra.infra_id;
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
@@ -346,7 +344,7 @@ async fn create(
     }
 
     let infra: Changeset<Infra> = infra_form.into();
-    let infra = infra.create(db_pool.get().await?.deref_mut()).await?;
+    let infra = infra.create(&mut db_pool.get().await?).await?;
     Ok((StatusCode::CREATED, Json(infra)))
 }
 
@@ -381,13 +379,13 @@ async fn clone(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), params.infra_id, || {
-        InfraApiError::NotFound {
-            infra_id: params.infra_id,
-        }
+    let conn = &mut db_pool.get().await?;
+
+    let infra = Infra::retrieve_or_fail(conn, params.infra_id, || InfraApiError::NotFound {
+        infra_id: params.infra_id,
     })
     .await?;
-    let cloned_infra = infra.clone(db_pool.get().await?.deref_mut(), name).await?;
+    let cloned_infra = infra.clone(conn, name).await?;
     Ok(Json(cloned_infra.id))
 }
 
@@ -425,7 +423,7 @@ async fn delete(
     let db_pool = app_state.db_pool_v2.clone();
     let infra_caches = app_state.infra_caches.clone();
     let infra_id = infra.infra_id;
-    if Infra::fast_delete_static(db_pool.get().await?.deref_mut(), infra_id).await? {
+    if Infra::fast_delete_static(db_pool.get().await?, infra_id).await? {
         infra_caches.remove(&infra_id);
         Ok(StatusCode::NO_CONTENT)
     } else {
@@ -472,7 +470,7 @@ async fn put(
 
     let infra_cs: Changeset<Infra> = patch.into();
     let infra = infra_cs
-        .update_or_fail(db_pool.get().await?.deref_mut(), infra, || {
+        .update_or_fail(&mut db_pool.get().await?, infra, || {
             InfraApiError::NotFound { infra_id: infra }
         })
         .await?;
@@ -503,17 +501,15 @@ async fn get_switch_types(
     }
 
     let db_pool = app_state.db_pool_v2.clone();
+    let conn = &mut db_pool.get().await?;
     let infra_caches = app_state.infra_caches.clone();
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra.infra_id, || {
-        InfraApiError::NotFound {
-            infra_id: infra.infra_id,
-        }
+    let infra = Infra::retrieve_or_fail(conn, infra.infra_id, || InfraApiError::NotFound {
+        infra_id: infra.infra_id,
     })
     .await?;
 
-    let infra =
-        InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra).await?;
+    let infra = InfraCache::get_or_load(conn, &infra_caches, &infra).await?;
     Ok(Json(
         infra
             .switch_types()
@@ -547,15 +543,13 @@ async fn get_speed_limit_tags(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra.infra_id, || {
-        InfraApiError::NotFound {
-            infra_id: infra.infra_id,
-        }
+    let conn = &mut db_pool.get().await?;
+
+    let infra = Infra::retrieve_or_fail(conn, infra.infra_id, || InfraApiError::NotFound {
+        infra_id: infra.infra_id,
     })
     .await?;
-    let speed_limits_tags = infra
-        .get_speed_limit_tags(db_pool.get().await?.deref_mut())
-        .await?;
+    let speed_limits_tags = infra.get_speed_limit_tags(conn).await?;
     Ok(Json(
         speed_limits_tags.into_iter().map(|el| (el.tag)).collect(),
     ))
@@ -594,17 +588,14 @@ async fn get_voltages(
     }
 
     let include_rolling_stock_modes = param.include_rolling_stock_modes;
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra.infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra.infra_id, || {
         InfraApiError::NotFound {
             infra_id: infra.infra_id,
         }
     })
     .await?;
     let voltages = infra
-        .get_voltages(
-            db_pool.get().await?.deref_mut(),
-            include_rolling_stock_modes,
-        )
+        .get_voltages(&mut db_pool.get().await?, include_rolling_stock_modes)
         .await?;
     Ok(Json(voltages.into_iter().map(|el| (el.voltage)).collect()))
 }
@@ -630,17 +621,17 @@ async fn get_all_voltages(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let voltages = Infra::get_all_voltages(db_pool.get().await?.deref_mut()).await?;
+    let voltages = Infra::get_all_voltages(&mut db_pool.get().await?).await?;
     Ok(Json(voltages.into_iter().map(|el| (el.voltage)).collect()))
 }
 
 async fn set_locked(infra_id: i64, locked: bool, db_pool: DbConnectionPoolV2) -> Result<()> {
-    let mut infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let mut infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
     infra.locked = locked;
-    infra.save(db_pool.get().await?.deref_mut()).await
+    infra.save(&mut db_pool.get().await?).await
 }
 
 /// Lock an infra
@@ -724,7 +715,7 @@ async fn load(
     let core_client = app_state.core_client.clone();
 
     let infra_id = path.infra_id;
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
@@ -803,13 +794,13 @@ pub mod tests {
     async fn infra_clone_empty() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let request =
             app.post(format!("/infra/{}/clone/?name=cloned_infra", empty_infra.id).as_str());
 
         let cloned_infra_id: i64 = app.fetch(request).assert_status(StatusCode::OK).json_into();
-        let cloned_infra = Infra::retrieve(db_pool.get_ok().deref_mut(), cloned_infra_id)
+        let cloned_infra = Infra::retrieve(&mut db_pool.get_ok(), cloned_infra_id)
             .await
             .unwrap()
             .expect("infra was not cloned");
@@ -827,9 +818,9 @@ pub mod tests {
     async fn infra_clone() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let small_infra_id = small_infra.id;
-        let infra_cache = InfraCache::load(db_pool.get_ok().deref_mut(), &small_infra)
+        let infra_cache = InfraCache::load(&mut db_pool.get_ok(), &small_infra)
             .await
             .unwrap();
 
@@ -842,7 +833,7 @@ pub mod tests {
             ..Default::default()
         }
         .into();
-        apply_create_operation(&switch_type, small_infra_id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&switch_type, small_infra_id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create switch_type object");
 
@@ -854,7 +845,7 @@ pub mod tests {
             .assert_status(StatusCode::OK)
             .json_into();
 
-        let _cloned_infra = Infra::retrieve(db_pool.get_ok().deref_mut(), cloned_infra_id)
+        let _cloned_infra = Infra::retrieve(&mut db_pool.get_ok(), cloned_infra_id)
             .await
             .unwrap()
             .expect("infra was not cloned");
@@ -876,7 +867,7 @@ pub mod tests {
                     table
                 ))
                 .bind::<BigInt, _>(inf_id)
-                .get_result::<Count>(db_pool.get_ok().deref_mut())
+                .get_result::<Count>(&mut db_pool.get_ok().write().await.deref_mut())
                 .await
                 .unwrap();
 
@@ -905,7 +896,7 @@ pub mod tests {
             .core_client(CoreClient::default())
             .build();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         app.fetch(app.delete_infra_request(empty_infra.id))
             .assert_status(StatusCode::NO_CONTENT);
@@ -954,16 +945,13 @@ pub mod tests {
             .db_pool(db_pool.clone())
             .core_client(core.into())
             .build();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req = app.get(format!("/infra/{}", empty_infra.id).as_str());
 
         app.fetch(req).assert_status(StatusCode::OK);
 
-        empty_infra
-            .delete(db_pool.get_ok().deref_mut())
-            .await
-            .unwrap();
+        empty_infra.delete(&mut db_pool.get_ok()).await.unwrap();
 
         let req = app.get(format!("/infra/{}", empty_infra.id).as_str());
 
@@ -974,7 +962,7 @@ pub mod tests {
     async fn infra_rename() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req = app
             .put(format!("/infra/{}", empty_infra.id).as_str())
@@ -994,7 +982,7 @@ pub mod tests {
     async fn infra_refresh() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req = app.post(format!("/infra/refresh/?infras={}", empty_infra.id).as_str());
 
@@ -1010,7 +998,7 @@ pub mod tests {
     async fn infra_refresh_force() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req =
             app.post(format!("/infra/refresh/?infras={}&force=true", empty_infra.id).as_str());
@@ -1023,14 +1011,14 @@ pub mod tests {
     async fn infra_get_speed_limit_tags() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let speed_section = SpeedSection {
             speed_limit_by_tag: HashMap::from([("test_tag".into(), Speed(10.))]),
             ..Default::default()
         }
         .into();
-        apply_create_operation(&speed_section, empty_infra.id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&speed_section, empty_infra.id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create speed section object");
 
@@ -1046,8 +1034,8 @@ pub mod tests {
     async fn infra_get_all_voltages() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let infra_1 = create_empty_infra(db_pool.get_ok().deref_mut()).await;
-        let infra_2 = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let infra_1 = create_empty_infra(&mut db_pool.get_ok()).await;
+        let infra_2 = create_empty_infra(&mut db_pool.get_ok()).await;
 
         // Create electrifications
         let electrification_1 = Electrification {
@@ -1056,7 +1044,7 @@ pub mod tests {
             track_ranges: vec![],
         }
         .into();
-        apply_create_operation(&electrification_1, infra_1.id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&electrification_1, infra_1.id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create electrification_1 object");
 
@@ -1066,13 +1054,13 @@ pub mod tests {
             track_ranges: vec![],
         }
         .into();
-        apply_create_operation(&electrification_2, infra_2.id, db_pool.get_ok().deref_mut())
+        apply_create_operation(&electrification_2, infra_2.id, &mut db_pool.get_ok())
             .await
             .expect("Failed to create electrification_2 object");
 
         // Create rolling_stock
         let _rolling_stock = create_rolling_stock_with_energy_sources(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             "other_rolling_stock_infra_get_all_voltages",
         )
         .await;
@@ -1093,7 +1081,7 @@ pub mod tests {
     async fn infra_get_voltages(#[case] include_rolling_stock_modes: bool) {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         // Create electrification
         let electrification = Electrification {
@@ -1102,17 +1090,13 @@ pub mod tests {
             track_ranges: vec![],
         }
         .into();
-        apply_create_operation(
-            &electrification,
-            empty_infra.id,
-            db_pool.get_ok().deref_mut(),
-        )
-        .await
-        .expect("Failed to create electrification object");
+        apply_create_operation(&electrification, empty_infra.id, &mut db_pool.get_ok())
+            .await
+            .expect("Failed to create electrification object");
 
         // Create rolling_stock
         let _rolling_stock = create_rolling_stock_with_energy_sources(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             "other_rolling_stock_infra_get_voltages",
         )
         .await;
@@ -1140,7 +1124,7 @@ pub mod tests {
     async fn infra_get_switch_types() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req = app.get(format!("/infra/{}/switch_types/", empty_infra.id).as_str());
 
@@ -1164,7 +1148,7 @@ pub mod tests {
             .db_pool(db_pool.clone())
             .core_client(core.into())
             .build();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         // Lock infra
         let req = app.post(format!("/infra/{}/lock/", empty_infra.id).as_str());
@@ -1172,7 +1156,7 @@ pub mod tests {
         app.fetch(req).assert_status(StatusCode::NO_CONTENT);
 
         // Check lock
-        let infra = Infra::retrieve(db_pool.get_ok().deref_mut(), empty_infra.id)
+        let infra = Infra::retrieve(&mut db_pool.get_ok(), empty_infra.id)
             .await
             .unwrap()
             .expect("infra was not cloned");
@@ -1184,7 +1168,7 @@ pub mod tests {
         app.fetch(req).assert_status(StatusCode::NO_CONTENT);
 
         // Check lock
-        let infra = Infra::retrieve(db_pool.get_ok().deref_mut(), empty_infra.id)
+        let infra = Infra::retrieve(&mut db_pool.get_ok(), empty_infra.id)
             .await
             .unwrap()
             .expect("infra was not cloned");
@@ -1205,7 +1189,7 @@ pub mod tests {
             .db_pool(db_pool.clone())
             .core_client(core.into())
             .build();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let req = app.post(format!("/infra/{}/load", empty_infra.id).as_str());
 
diff --git a/editoast/src/views/infra/objects.rs b/editoast/src/views/infra/objects.rs
index 365563fde36..7a1466e3aca 100644
--- a/editoast/src/views/infra/objects.rs
+++ b/editoast/src/views/infra/objects.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::ops::DerefMut;
 
 use axum::extract::Json;
 use axum::extract::Path;
@@ -76,13 +75,13 @@ async fn get_objects(
         return Err(GetObjectsErrors::DuplicateIdsProvided.into());
     }
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
     let objects = infra
         .get_objects(
-            db_pool.get().await?.deref_mut(),
+            &mut db_pool.get().await?,
             object_type_param.object_type,
             &obj_ids,
         )
@@ -122,7 +121,6 @@ mod tests {
     use rstest::rstest;
     use serde_json::json;
     use serde_json::Value as JsonValue;
-    use std::ops::DerefMut;
 
     use crate::infra_cache::operation::create::apply_create_operation;
     use crate::modelsv2::fixtures::create_empty_infra;
@@ -136,7 +134,7 @@ mod tests {
     async fn check_invalid_ids() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let request = app
             .post(format!("/infra/{}/objects/TrackSection", empty_infra.id).as_str())
@@ -149,7 +147,7 @@ mod tests {
     async fn get_objects_no_ids() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let request = app
             .post(format!("/infra/{}/objects/TrackSection", empty_infra.id).as_str())
@@ -163,7 +161,7 @@ mod tests {
         // GIVEN
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let switch = Switch {
             id: "switch_001".into(),
@@ -173,7 +171,7 @@ mod tests {
         apply_create_operation(
             &switch.clone().into(),
             empty_infra.id,
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
         )
         .await
         .expect("Failed to create switch object");
@@ -206,7 +204,7 @@ mod tests {
     async fn get_objects_duplicate_ids() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let request = app
             .post(format!("/infra/{}/objects/TrackSection", empty_infra.id).as_str())
@@ -219,14 +217,14 @@ mod tests {
     async fn get_switch_types() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         // Add a switch type
         let switch_type = SwitchType::default();
         apply_create_operation(
             &switch_type.clone().into(),
             empty_infra.id,
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
         )
         .await
         .expect("Failed to create switch type object");
diff --git a/editoast/src/views/infra/pathfinding.rs b/editoast/src/views/infra/pathfinding.rs
index 4c0571316d5..3e1a342f480 100644
--- a/editoast/src/views/infra/pathfinding.rs
+++ b/editoast/src/views/infra/pathfinding.rs
@@ -11,7 +11,6 @@ use editoast_derive::EditoastError;
 use pathfinding::prelude::yen;
 use serde::Deserialize;
 use serde::Serialize;
-use std::ops::DerefMut;
 use thiserror::Error;
 use utoipa::IntoParams;
 use utoipa::ToSchema;
@@ -126,12 +125,12 @@ async fn pathfinding_view(
     }
 
     // TODO: lock for share
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
     let infra_cache =
-        InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra).await?;
+        InfraCache::get_or_load(&mut db_pool.get().await?, &infra_caches, &infra).await?;
 
     // Check that the starting and ending track locations are valid
     if !infra_cache
diff --git a/editoast/src/views/infra/railjson.rs b/editoast/src/views/infra/railjson.rs
index 78195008944..4116c204d7e 100644
--- a/editoast/src/views/infra/railjson.rs
+++ b/editoast/src/views/infra/railjson.rs
@@ -14,7 +14,6 @@ use enum_map::EnumMap;
 use futures::future::try_join_all;
 use serde::Deserialize;
 use serde::Serialize;
-use std::ops::DerefMut;
 use strum::IntoEnumIterator;
 use thiserror::Error;
 use utoipa::IntoParams;
@@ -68,7 +67,7 @@ async fn get_railjson(
     }
 
     let infra_id = infra.infra_id;
-    let infra_meta = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra_meta = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
@@ -190,18 +189,17 @@ async fn post_railjson(
     let mut infra = Infra::changeset()
         .name(params.name.clone())
         .last_railjson_version()
-        .persist(railjson, db_pool.get().await?.deref_mut())
+        .persist(railjson, &mut db_pool.get().await?)
         .await?;
     let infra_id = infra.id;
 
     infra
-        .bump_version(db_pool.get().await?.deref_mut())
+        .bump_version(&mut db_pool.get().await?)
         .await
         .map_err(|_| InfraApiError::NotFound { infra_id })?;
     if params.generate_data {
         let infra_cache =
-            InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra)
-                .await?;
+            InfraCache::get_or_load(&mut db_pool.get().await?, &infra_caches, &infra).await?;
         infra.refresh(db_pool, true, &infra_cache).await?;
     }
 
@@ -226,12 +224,12 @@ mod tests {
     async fn test_get_railjson() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         apply_create_operation(
             &SwitchType::default().into(),
             empty_infra.id,
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
         )
         .await
         .expect("Failed to create SwitchType object");
@@ -271,10 +269,8 @@ mod tests {
 
         let res: PostRailjsonResponse = app.fetch(req).assert_status(StatusCode::OK).json_into();
 
-        assert!(
-            Infra::delete_static(db_pool.get_ok().deref_mut(), res.infra)
-                .await
-                .unwrap()
-        );
+        assert!(Infra::delete_static(&mut db_pool.get_ok(), res.infra)
+            .await
+            .unwrap());
     }
 }
diff --git a/editoast/src/views/infra/routes.rs b/editoast/src/views/infra/routes.rs
index 73f41803b83..3a1b6551e3a 100644
--- a/editoast/src/views/infra/routes.rs
+++ b/editoast/src/views/infra/routes.rs
@@ -10,7 +10,6 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::ops::DerefMut;
 use strum::Display;
 use utoipa::ToSchema;
 
@@ -79,19 +78,15 @@ async fn get_routes_from_waypoint(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), path.infra_id, || {
-        InfraApiError::NotFound {
-            infra_id: path.infra_id,
-        }
+    let conn = &mut db_pool.get().await?;
+
+    let infra = Infra::retrieve_or_fail(conn, path.infra_id, || InfraApiError::NotFound {
+        infra_id: path.infra_id,
     })
     .await?;
 
     let routes = infra
-        .get_routes_from_waypoint(
-            db_pool.get().await?.deref_mut(),
-            &path.waypoint_id,
-            path.waypoint_type.to_string(),
-        )
+        .get_routes_from_waypoint(conn, &path.waypoint_id, path.waypoint_type.to_string())
         .await?;
 
     // Split routes depending if they are entry or exit points
@@ -166,13 +161,13 @@ async fn get_routes_track_ranges(
     let db_pool = app_state.db_pool_v2.clone();
     let infra_caches = app_state.infra_caches.clone();
     let infra_id = infra;
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         InfraApiError::NotFound { infra_id }
     })
     .await?;
 
     let infra_cache =
-        InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra).await?;
+        InfraCache::get_or_load(&mut db_pool.get().await?, &infra_caches, &infra).await?;
     let graph = Graph::load(&infra_cache);
     let routes_cache = infra_cache.routes();
     let result = params
@@ -227,7 +222,7 @@ async fn get_routes_nodes(
     let db_pool = app_state.db_pool_v2.clone();
     let infra_caches = app_state.infra_caches.clone();
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), params.infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, params.infra_id, || {
         InfraApiError::NotFound {
             infra_id: params.infra_id,
         }
@@ -239,7 +234,7 @@ async fn get_routes_nodes(
     }
 
     let infra_cache =
-        InfraCache::get_or_load(db_pool.get().await?.deref_mut(), &infra_caches, &infra).await?;
+        InfraCache::get_or_load(&mut db_pool.get().await?, &infra_caches, &infra).await?;
     let routes_cache = infra_cache.routes();
 
     let filtered_routes = routes_cache
@@ -314,7 +309,6 @@ mod tests {
     use editoast_schemas::infra::Route;
     use editoast_schemas::infra::TrackSection;
     use editoast_schemas::infra::Waypoint;
-    use std::ops::DerefMut;
 
     #[rstest]
     async fn get_routes_nodes() {
@@ -385,7 +379,7 @@ mod tests {
 
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
 
         fn compare_result(got: RoutesFromNodesPositions, expected: RoutesFromNodesPositions) {
             let mut got_routes = got.routes;
@@ -437,7 +431,7 @@ mod tests {
     async fn get_routes_should_return_routes_from_buffer_stop_and_detector() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
         let empty_infra_id = empty_infra.id;
 
         let track = TrackSection {
@@ -482,7 +476,7 @@ mod tests {
         }
         .into();
         for obj in [track, detector, bs_start, bs_stop, route_1, route_2] {
-            apply_create_operation(&obj, empty_infra_id, db_pool.get_ok().deref_mut())
+            apply_create_operation(&obj, empty_infra_id, &mut db_pool.get_ok())
                 .await
                 .expect("Failed to create track object");
         }
@@ -522,7 +516,7 @@ mod tests {
     async fn get_routes_should_return_empty_response() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let empty_infra = create_empty_infra(db_pool.get_ok().deref_mut()).await;
+        let empty_infra = create_empty_infra(&mut db_pool.get_ok()).await;
 
         let waypoint_type = WaypointType::Detector;
         let request = app.get(
diff --git a/editoast/src/views/mod.rs b/editoast/src/views/mod.rs
index 6ec761e35ce..da1d6759b52 100644
--- a/editoast/src/views/mod.rs
+++ b/editoast/src/views/mod.rs
@@ -22,7 +22,6 @@ pub mod work_schedules;
 #[cfg(test)]
 mod test_app;
 
-use std::ops::DerefMut as _;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -214,7 +213,7 @@ async fn check_health(
 ) -> Result<()> {
     let mut db_connection = db_pool.clone().get().await?;
     tokio::try_join!(
-        ping_database(db_connection.deref_mut()).map_err(AppHealthError::Database),
+        ping_database(&mut db_connection).map_err(AppHealthError::Database),
         redis_client.ping_redis().map_err(|e| e.into())
     )?;
     Ok(())
diff --git a/editoast/src/views/pagination.rs b/editoast/src/views/pagination.rs
index 685c06c278b..4d7b5f0e23a 100644
--- a/editoast/src/views/pagination.rs
+++ b/editoast/src/views/pagination.rs
@@ -1,4 +1,5 @@
 use editoast_derive::EditoastError;
+use editoast_models::DbConnection;
 use serde::Deserialize;
 use serde::Serialize;
 use thiserror::Error;
@@ -10,7 +11,6 @@ use crate::error::Result;
 use crate::ListAndCount;
 use crate::Model;
 use crate::SelectionSettings;
-use editoast_models::DbConnection;
 
 editoast_common::schemas! {
     PaginationStats,
diff --git a/editoast/src/views/projects.rs b/editoast/src/views/projects.rs
index f23b5d89b1e..16599de993f 100644
--- a/editoast/src/views/projects.rs
+++ b/editoast/src/views/projects.rs
@@ -1,5 +1,3 @@
-use std::ops::DerefMut;
-
 use axum::extract::Json;
 use axum::extract::Path;
 use axum::extract::Query;
@@ -201,6 +199,7 @@ async fn list(
     if !authorized {
         return Err(AuthorizationError::Unauthorized.into());
     }
+
     let ordering = ordering_params.ordering;
     let settings = pagination_params
         .validate(1000)?
@@ -208,14 +207,15 @@ async fn list(
         .into_selection_settings()
         .order_by(move || ordering.as_project_ordering());
 
-    let (projects, stats) =
-        Project::list_paginated(db_pool.get().await?.deref_mut(), settings).await?;
+    let conn = &mut db_pool.get().await?;
+
+    let (projects, stats) = Project::list_paginated(conn, settings).await?;
 
     let results = projects
         .into_iter()
         .zip(db_pool.iter_conn())
         .map(|(project, conn)| async move {
-            ProjectWithStudyCount::try_fetch(conn.await?.deref_mut(), project).await
+            ProjectWithStudyCount::try_fetch(&mut conn.await?, project).await
         });
     let results = futures::future::try_join_all(results).await?;
     Ok(Json(ProjectWithStudyCountList { results, stats }))
@@ -360,7 +360,6 @@ async fn patch(
 pub mod test {
     use std::collections::HashMap;
     use std::collections::HashSet;
-    use std::ops::DerefMut;
 
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
@@ -391,7 +390,7 @@ pub mod test {
         let response: ProjectWithStudyCount =
             app.fetch(request).assert_status(StatusCode::OK).json_into();
 
-        let project = Project::retrieve(pool.get_ok().deref_mut(), response.project.id)
+        let project = Project::retrieve(&mut pool.get_ok(), response.project.id)
             .await
             .expect("Failed to retrieve project")
             .expect("Project not found");
@@ -427,8 +426,7 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let request = app.get("/projects/");
 
@@ -449,8 +447,7 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let request = app.get(format!("/projects/{}", created_project.id).as_str());
 
@@ -465,14 +462,13 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let request = app.delete(format!("/projects/{}", created_project.id).as_str());
 
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
-        let exists = Project::exists(db_pool.get_ok().deref_mut(), created_project.id)
+        let exists = Project::exists(&mut db_pool.get_ok(), created_project.id)
             .await
             .expect("Failed to check if project exists");
 
@@ -484,8 +480,7 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let updated_name = "rename_test";
         let updated_budget = 20000;
@@ -502,7 +497,7 @@ pub mod test {
 
         assert_eq!(response.project, response.project);
 
-        let project = Project::retrieve(db_pool.get_ok().deref_mut(), response.project.id)
+        let project = Project::retrieve(&mut db_pool.get_ok(), response.project.id)
             .await
             .expect("Failed to retrieve project")
             .expect("Project not found");
diff --git a/editoast/src/views/rolling_stock.rs b/editoast/src/views/rolling_stock.rs
index 4ee23f70efc..a53fed20e3e 100644
--- a/editoast/src/views/rolling_stock.rs
+++ b/editoast/src/views/rolling_stock.rs
@@ -4,7 +4,6 @@ pub mod light;
 pub use form::RollingStockForm;
 
 use std::io::Cursor;
-use std::ops::DerefMut;
 
 use axum::extract::Json;
 use axum::extract::Multipart;
@@ -221,13 +220,12 @@ async fn get(
         return Err(AuthorizationError::Unauthorized.into());
     }
     let rolling_stock = retrieve_existing_rolling_stock(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         RollingStockKey::Id(rolling_stock_id),
     )
     .await?;
     let rolling_stock_with_liveries =
-        RollingStockWithLiveries::try_fetch(db_pool.get().await?.deref_mut(), rolling_stock)
-            .await?;
+        RollingStockWithLiveries::try_fetch(&mut db_pool.get().await?, rolling_stock).await?;
     Ok(Json(rolling_stock_with_liveries))
 }
 
@@ -254,13 +252,12 @@ async fn get_by_name(
     }
 
     let rolling_stock = retrieve_existing_rolling_stock(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         RollingStockKey::Name(rolling_stock_name),
     )
     .await?;
     let rolling_stock_with_liveries =
-        RollingStockWithLiveries::try_fetch(db_pool.get().await?.deref_mut(), rolling_stock)
-            .await?;
+        RollingStockWithLiveries::try_fetch(&mut db_pool.get().await?, rolling_stock).await?;
     Ok(Json(rolling_stock_with_liveries))
 }
 
@@ -364,18 +361,17 @@ async fn update(
     rolling_stock_form.validate()?;
     let name = rolling_stock_form.name.clone();
 
-    let previous_rolling_stock = RollingStockModel::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
-        rolling_stock_id,
-        || RollingStockError::KeyNotFound {
-            rolling_stock_key: RollingStockKey::Id(rolling_stock_id),
-        },
-    )
-    .await?;
+    let previous_rolling_stock =
+        RollingStockModel::retrieve_or_fail(&mut db_pool.get().await?, rolling_stock_id, || {
+            RollingStockError::KeyNotFound {
+                rolling_stock_key: RollingStockKey::Id(rolling_stock_id),
+            }
+        })
+        .await?;
     assert_rolling_stock_unlocked(&previous_rolling_stock)?;
 
     let mut new_rolling_stock = Into::<Changeset<RollingStockModel>>::into(rolling_stock_form)
-        .update(db_pool.get().await?.deref_mut(), rolling_stock_id)
+        .update(&mut db_pool.get().await?, rolling_stock_id)
         .await
         .map_err(|e| map_diesel_error(e, name.clone()))?
         .ok_or(RollingStockError::KeyNotFound {
@@ -385,14 +381,13 @@ async fn update(
     if new_rolling_stock != previous_rolling_stock {
         new_rolling_stock.version += 1;
         new_rolling_stock
-            .save(db_pool.get().await?.deref_mut())
+            .save(&mut db_pool.get().await?)
             .await
             .map_err(|err| map_diesel_error(err, name))?;
     }
 
     let new_rolling_stock_with_liveries =
-        RollingStockWithLiveries::try_fetch(db_pool.get().await?.deref_mut(), new_rolling_stock)
-            .await?;
+        RollingStockWithLiveries::try_fetch(&mut db_pool.get().await?, new_rolling_stock).await?;
 
     Ok(Json(new_rolling_stock_with_liveries))
 }
@@ -769,8 +764,6 @@ async fn create_compound_image(
 
 #[cfg(test)]
 pub mod tests {
-    use std::ops::DerefMut;
-
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
@@ -826,7 +819,7 @@ pub mod tests {
 
         // THEN
         // Check if the rolling stock was created in the database
-        let rolling_stock = RollingStockModel::retrieve(db_pool.get_ok().deref_mut(), response.id)
+        let rolling_stock = RollingStockModel::retrieve(&mut db_pool.get_ok(), response.id)
             .await
             .expect("Failed to retrieve rolling stock")
             .expect("Rolling stock not found");
@@ -857,7 +850,7 @@ pub mod tests {
 
         // THEN
         // Check if the rolling stock was created in the database with locked = true
-        let rolling_stock = RollingStockModel::retrieve(db_pool.get_ok().deref_mut(), response.id)
+        let rolling_stock = RollingStockModel::retrieve(&mut db_pool.get_ok(), response.id)
             .await
             .expect("Failed to retrieve rolling stock")
             .expect("Rolling stock not found");
@@ -872,7 +865,7 @@ pub mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let _ = create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let _ = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
         let new_fast_rolling_stock_form = fast_rolling_stock_form(rs_name);
 
         let request = app.rolling_stock_create_request(&new_fast_rolling_stock_form);
@@ -914,19 +907,18 @@ pub mod tests {
             .assert_status(StatusCode::OK)
             .json_into();
 
-        let project =
-            create_project(db_pool.get_ok().deref_mut(), &Uuid::new_v4().to_string()).await;
+        let project = create_project(&mut db_pool.get_ok(), &Uuid::new_v4().to_string()).await;
         let study = create_study(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             &Uuid::new_v4().to_string(),
             project.id,
         )
         .await;
-        let timetable_1 = create_timetable(db_pool.get_ok().deref_mut()).await;
-        let timetable_2 = create_timetable(db_pool.get_ok().deref_mut()).await;
-        let infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let timetable_1 = create_timetable(&mut db_pool.get_ok()).await;
+        let timetable_2 = create_timetable(&mut db_pool.get_ok()).await;
+        let infra = create_small_infra(&mut db_pool.get_ok()).await;
         let scenario_1 = create_scenario(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             &Uuid::new_v4().to_string(),
             study.id,
             timetable_1.id,
@@ -934,7 +926,7 @@ pub mod tests {
         )
         .await;
         let scenario_2 = create_scenario(
-            db_pool.get_ok().deref_mut(),
+            &mut db_pool.get_ok(),
             &Uuid::new_v4().to_string(),
             study.id,
             timetable_2.id,
@@ -951,12 +943,12 @@ pub mod tests {
         schedule_form_2.train_schedule.rolling_stock_name = rolling_stock.name;
         let train_schedule_1: Changeset<TrainSchedule> = schedule_form_1.into();
         let _ = train_schedule_1
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .unwrap();
         let train_schedule_2: Changeset<TrainSchedule> = schedule_form_2.into();
         let _ = train_schedule_2
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .unwrap();
 
@@ -988,7 +980,7 @@ pub mod tests {
     async fn get_invalid_rolling_stock_id_returns_404_not_found() {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
-        let _ = RollingStockModel::delete_static(db_pool.get_ok().deref_mut(), 1).await;
+        let _ = RollingStockModel::delete_static(&mut db_pool.get_ok(), 1).await;
 
         let request = app.get("/rolling_stock/1/usage");
         app.fetch(request).assert_status(StatusCode::NOT_FOUND);
@@ -1043,8 +1035,7 @@ pub mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         let request = app.rolling_stock_get_by_id_request(fast_rolling_stock.id);
 
@@ -1063,8 +1054,7 @@ pub mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         let request = app.get(format!("/rolling_stock/name/{rs_name}").as_str());
 
@@ -1102,8 +1092,7 @@ pub mod tests {
 
         let rs_name = "fast_rolling_stock_name";
 
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         let mut rolling_stock_form: RollingStockForm = fast_rolling_stock.clone().into();
         let updated_rs_name = "updated_fast_rolling_stock_name";
@@ -1119,7 +1108,7 @@ pub mod tests {
         // THEN
 
         let updated_rolling_stock: RollingStockModel =
-            RollingStockModel::retrieve(db_pool.get_ok().deref_mut(), fast_rolling_stock.id)
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), fast_rolling_stock.id)
                 .await
                 .expect("Failed to retrieve rolling stock")
                 .expect("Rolling stock not found");
@@ -1139,12 +1128,11 @@ pub mod tests {
 
         let first_rs_name = "first_fast_rolling_stock_name";
         let first_fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), first_rs_name).await;
+            create_fast_rolling_stock(&mut db_pool.get_ok(), first_rs_name).await;
 
         let second_rs_name = "second_fast_rolling_stock_name";
         let second_fast_rolling_stock =
-            create_rolling_stock_with_energy_sources(db_pool.get_ok().deref_mut(), second_rs_name)
-                .await;
+            create_rolling_stock_with_energy_sources(&mut db_pool.get_ok(), second_rs_name).await;
 
         let second_fast_rolling_stock_form: RollingStockForm = second_fast_rolling_stock.into();
 
@@ -1176,7 +1164,7 @@ pub mod tests {
         let locked_fast_rolling_stock_changeset =
             fast_rolling_stock_changeset(locked_rs_name).locked(true);
         let locked_fast_rolling_stock = locked_fast_rolling_stock_changeset
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .expect("Failed to create rolling stock");
 
@@ -1206,8 +1194,7 @@ pub mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         assert!(!fast_rolling_stock.locked);
 
@@ -1218,7 +1205,7 @@ pub mod tests {
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
         let fast_rolling_stock: RollingStockModel =
-            RollingStockModel::retrieve(db_pool.get_ok().deref_mut(), fast_rolling_stock.id)
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), fast_rolling_stock.id)
                 .await
                 .expect("Failed to retrieve rolling stock")
                 .expect("Rolling stock not found");
@@ -1236,7 +1223,7 @@ pub mod tests {
         let locked_fast_rolling_stock_changeset =
             fast_rolling_stock_changeset(locked_rs_name).locked(true);
         let locked_fast_rolling_stock = locked_fast_rolling_stock_changeset
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .expect("Failed to create rolling stock");
         assert!(locked_fast_rolling_stock.locked);
@@ -1248,7 +1235,7 @@ pub mod tests {
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
         let fast_rolling_stock: RollingStockModel =
-            RollingStockModel::retrieve(db_pool.get_ok().deref_mut(), locked_fast_rolling_stock.id)
+            RollingStockModel::retrieve(&mut db_pool.get_ok(), locked_fast_rolling_stock.id)
                 .await
                 .expect("Failed to retrieve rolling stock")
                 .expect("Rolling stock not found");
@@ -1263,8 +1250,7 @@ pub mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
         let power_restrictions = fast_rolling_stock.power_restrictions.clone();
 
         let request = app.get("/rolling_stock/power_restrictions");
@@ -1292,7 +1278,7 @@ pub mod tests {
         let locked_fast_rolling_stock_changeset =
             fast_rolling_stock_changeset(locked_rs_name).locked(true);
         let locked_fast_rolling_stock = locked_fast_rolling_stock_changeset
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .expect("Failed to create rolling stock");
 
@@ -1312,7 +1298,7 @@ pub mod tests {
         );
 
         let rolling_stock_exists =
-            RollingStockModel::exists(db_pool.get_ok().deref_mut(), locked_fast_rolling_stock.id)
+            RollingStockModel::exists(&mut db_pool.get_ok(), locked_fast_rolling_stock.id)
                 .await
                 .expect("Failed to check if rolling stock exists");
 
diff --git a/editoast/src/views/rolling_stock/light.rs b/editoast/src/views/rolling_stock/light.rs
index 96894c5a4a9..78c3e5cde81 100644
--- a/editoast/src/views/rolling_stock/light.rs
+++ b/editoast/src/views/rolling_stock/light.rs
@@ -18,7 +18,6 @@ use editoast_schemas::rolling_stock::RollingStockSupportedSignalingSystems;
 use itertools::Itertools;
 use serde::Serialize;
 use std::collections::HashMap;
-use std::ops::DerefMut;
 use utoipa::ToSchema;
 
 use super::RollingStockError;
@@ -123,11 +122,11 @@ async fn list(
         .into_selection_settings()
         .order_by(|| RollingStockModel::ID.asc());
     let (rolling_stocks, stats) =
-        RollingStockModel::list_paginated(db_pool.get().await?.deref_mut(), settings).await?;
+        RollingStockModel::list_paginated(&mut db_pool.get().await?, settings).await?;
 
     let results = rolling_stocks.into_iter().zip(db_pool.iter_conn()).map(
         |(rolling_stock, conn)| async move {
-            LightRollingStockWithLiveries::try_fetch(conn.await?.deref_mut(), rolling_stock).await
+            LightRollingStockWithLiveries::try_fetch(&mut conn.await?, rolling_stock).await
         },
     );
 
@@ -161,7 +160,7 @@ async fn get(
         return Err(AuthorizationError::Unauthorized.into());
     }
     let rolling_stock = RollingStockModel::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         light_rolling_stock_id,
         || RollingStockError::KeyNotFound {
             rolling_stock_key: RollingStockKey::Id(light_rolling_stock_id),
@@ -169,8 +168,7 @@ async fn get(
     )
     .await?;
     let light_rolling_stock_with_liveries =
-        LightRollingStockWithLiveries::try_fetch(db_pool.get().await?.deref_mut(), rolling_stock)
-            .await?;
+        LightRollingStockWithLiveries::try_fetch(&mut db_pool.get().await?, rolling_stock).await?;
     Ok(Json(light_rolling_stock_with_liveries))
 }
 
@@ -196,7 +194,7 @@ async fn get_by_name(
         return Err(AuthorizationError::Unauthorized.into());
     }
     let rolling_stock = RollingStockModel::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         light_rolling_stock_name.clone(),
         || RollingStockError::KeyNotFound {
             rolling_stock_key: RollingStockKey::Name(light_rolling_stock_name),
@@ -204,8 +202,7 @@ async fn get_by_name(
     )
     .await?;
     let light_rolling_stock_with_liveries =
-        LightRollingStockWithLiveries::try_fetch(db_pool.get().await?.deref_mut(), rolling_stock)
-            .await?;
+        LightRollingStockWithLiveries::try_fetch(&mut db_pool.get().await?, rolling_stock).await?;
     Ok(Json(light_rolling_stock_with_liveries))
 }
 
@@ -329,7 +326,6 @@ impl From<ModeEffortCurves> for LightModeEffortCurves {
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;
-    use std::ops::DerefMut;
 
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
@@ -364,8 +360,7 @@ mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         let request = app.get(format!("/light_rolling_stock/{}", fast_rolling_stock.id).as_str());
 
@@ -384,8 +379,7 @@ mod tests {
         let db_pool = app.db_pool();
 
         let rs_name = "fast_rolling_stock_name";
-        let fast_rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), rs_name).await;
+        let fast_rolling_stock = create_fast_rolling_stock(&mut db_pool.get_ok(), rs_name).await;
 
         let request = app.get(format!("/light_rolling_stock/name/{}", rs_name).as_str());
 
@@ -416,7 +410,7 @@ mod tests {
             .zip(std::iter::repeat(&db_pool).map(|p| p.get()))
             .map(|(rs_id, conn)| async move {
                 let fixtures = create_rolling_stock_livery_fixture(
-                    conn.await.unwrap().deref_mut(),
+                    &mut conn.await.unwrap(),
                     &format!("rs_name_{}", rs_id),
                 )
                 .await;
diff --git a/editoast/src/views/scenario.rs b/editoast/src/views/scenario.rs
index 47cd0ad7e29..ac20b7e1333 100644
--- a/editoast/src/views/scenario.rs
+++ b/editoast/src/views/scenario.rs
@@ -1,5 +1,3 @@
-use std::ops::DerefMut as _;
-
 use axum::extract::Json;
 use axum::extract::Path;
 use axum::extract::Query;
@@ -9,7 +7,6 @@ use axum::Extension;
 use chrono::Utc;
 use derivative::Derivative;
 use diesel_async::scoped_futures::ScopedFutureExt;
-use diesel_async::AsyncConnection;
 use editoast_authz::BuiltinRole;
 use editoast_derive::EditoastError;
 use editoast_models::DbConnection;
@@ -213,32 +210,39 @@ async fn create(
         .get()
         .await?
         .transaction::<_, InternalError, _>(|conn| {
-            async {
+            async move {
                 // Check if the project and the study exist
-                let (mut project, study) = check_project_study(conn, project_id, study_id).await?;
+                let (mut project, study) =
+                    check_project_study(&mut conn.clone(), project_id, study_id).await?;
 
                 // Check if the timetable exists
-                let _ = Timetable::retrieve_or_fail(conn, timetable_id, || {
+                let _ = Timetable::retrieve_or_fail(&mut conn.clone(), timetable_id, || {
                     ScenarioError::TimetableNotFound { timetable_id }
                 })
                 .await?;
 
                 // Check if the infra exists
-                if !Infra::exists(conn, infra_id).await? {
+                if !Infra::exists(&mut conn.clone(), infra_id).await? {
                     return Err(ScenarioError::InfraNotFound { infra_id }.into());
                 }
 
                 // Create Scenario
-                let scenario = scenario.study_id(study_id).create(conn).await?;
+                let scenario = scenario
+                    .study_id(study_id)
+                    .create(&mut conn.clone())
+                    .await?;
 
                 // Update study last_modification field
-                study.clone().update_last_modified(conn).await?;
+                study
+                    .clone()
+                    .update_last_modified(&mut conn.clone())
+                    .await?;
 
                 // Update project last_modification field
-                project.update_last_modified(conn).await?;
+                project.update_last_modified(&mut conn.clone()).await?;
 
                 let scenarios_with_details =
-                    ScenarioWithDetails::from_scenario(scenario, conn).await?;
+                    ScenarioWithDetails::from_scenario(scenario, &mut conn.clone()).await?;
 
                 let scenarios_response =
                     ScenarioResponse::new(scenarios_with_details, project, study);
@@ -283,23 +287,27 @@ async fn delete(
         .get()
         .await?
         .transaction::<_, InternalError, _>(|conn| {
-            async {
+            async move {
                 // Check if the project and the study exist
-                let (mut project, study) = check_project_study(conn, project_id, study_id)
-                    .await
-                    .unwrap();
+                let (mut project, study) =
+                    check_project_study(&mut conn.clone(), project_id, study_id)
+                        .await
+                        .unwrap();
 
                 // Delete scenario
-                Scenario::delete_static_or_fail(conn, scenario_id, || ScenarioError::NotFound {
-                    scenario_id,
+                Scenario::delete_static_or_fail(&mut conn.clone(), scenario_id, || {
+                    ScenarioError::NotFound { scenario_id }
                 })
                 .await?;
 
                 // Update project last_modification field
-                project.update_last_modified(conn).await?;
+                project.update_last_modified(&mut conn.clone()).await?;
 
                 // Update study last_modification field
-                study.clone().update_last_modified(conn).await?;
+                study
+                    .clone()
+                    .update_last_modified(&mut conn.clone())
+                    .await?;
 
                 Ok(())
             }
@@ -366,13 +374,14 @@ async fn patch(
         .get()
         .await?
         .transaction::<_, InternalError, _>(|conn| {
-            async {
+            async move {
                 // Check if project and study exist
-                let (mut project, study) = check_project_study(conn, project_id, study_id).await?;
+                let (mut project, study) =
+                    check_project_study(&mut conn.clone(), project_id, study_id).await?;
 
                 // Check if the infra exists
                 if let Some(infra_id) = form.infra_id {
-                    if !Infra::exists(conn, infra_id).await? {
+                    if !Infra::exists(&mut conn.clone(), infra_id).await? {
                         return Err(ScenarioError::InfraNotFound { infra_id }.into());
                     }
                 }
@@ -380,19 +389,22 @@ async fn patch(
                 // Update the scenario
                 let scenario: Changeset<Scenario> = form.into();
                 let scenario = scenario
-                    .update_or_fail(conn, scenario_id, || ScenarioError::NotFound {
+                    .update_or_fail(&mut conn.clone(), scenario_id, || ScenarioError::NotFound {
                         scenario_id,
                     })
                     .await?;
 
                 // Update study last_modification field
-                study.clone().update_last_modified(conn).await?;
+                study
+                    .clone()
+                    .update_last_modified(&mut conn.clone())
+                    .await?;
 
                 // Update project last_modification field
-                project.update_last_modified(conn).await?;
+                project.update_last_modified(&mut conn.clone()).await?;
 
                 let scenario_with_details =
-                    ScenarioWithDetails::from_scenario(scenario, conn).await?;
+                    ScenarioWithDetails::from_scenario(scenario, &mut conn.clone()).await?;
 
                 let scenarios_response =
                     ScenarioResponse::new(scenario_with_details, project, study);
@@ -485,7 +497,9 @@ async fn list(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let _ = check_project_study(db_pool.get().await?.deref_mut(), project_id, study_id).await?;
+    let conn = &mut db_pool.get().await?;
+
+    let _ = check_project_study(conn, project_id, study_id).await?;
 
     let settings = pagination_params
         .validate(1000)?
@@ -493,14 +507,13 @@ async fn list(
         .into_selection_settings()
         .order_by(move || ordering.as_scenario_ordering())
         .filter(move || Scenario::STUDY_ID.eq(study_id));
-    let (scenarios, stats) =
-        Scenario::list_paginated(db_pool.get().await?.deref_mut(), settings).await?;
+    let (scenarios, stats) = Scenario::list_paginated(conn, settings).await?;
 
     let futs = scenarios
         .into_iter()
         .zip(std::iter::repeat(&db_pool).map(|p| p.get()))
         .map(|(scenario, conn)| async {
-            ScenarioWithDetails::from_scenario(scenario, conn.await?.deref_mut()).await
+            ScenarioWithDetails::from_scenario(scenario, &mut conn.await?).await
         });
     let results = futures::future::try_join_all(futs).await?;
 
@@ -536,8 +549,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(
             fixtures.project.id,
@@ -557,8 +569,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(fixtures.project.id, fixtures.study.id, None);
         let request = app.get(&url);
@@ -582,8 +593,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(fixtures.project.id, 99999999, Some(fixtures.scenario.id));
 
@@ -597,10 +607,10 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let project = create_project(pool.get_ok().deref_mut(), "project_test_name").await;
-        let study = create_study(pool.get_ok().deref_mut(), "study_test_name", project.id).await;
-        let infra = create_empty_infra(pool.get_ok().deref_mut()).await;
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
+        let project = create_project(&mut pool.get_ok(), "project_test_name").await;
+        let study = create_study(&mut pool.get_ok(), "study_test_name", project.id).await;
+        let infra = create_empty_infra(&mut pool.get_ok()).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
 
         let url = scenario_url(project.id, study.id, None);
 
@@ -628,7 +638,7 @@ mod tests {
         assert_eq!(response.scenario.timetable_id, study_timetable_id);
         assert_eq!(response.scenario.tags, study_tags);
 
-        let created_scenario = Scenario::retrieve(pool.get_ok().deref_mut(), response.scenario.id)
+        let created_scenario = Scenario::retrieve(&mut pool.get_ok(), response.scenario.id)
             .await
             .expect("Failed to retrieve scenario")
             .expect("Scenario not found");
@@ -645,8 +655,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(
             fixtures.project.id,
@@ -678,8 +687,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(
             fixtures.project.id,
@@ -700,9 +708,8 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
-        let other_infra = create_empty_infra(pool.get_ok().deref_mut()).await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
+        let other_infra = create_empty_infra(&mut pool.get_ok()).await;
 
         assert_eq!(fixtures.scenario.infra_id, fixtures.infra.id);
         assert_ne!(fixtures.scenario.infra_id, other_infra.id);
@@ -732,8 +739,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let fixtures =
-            create_scenario_fixtures_set(pool.get_ok().deref_mut(), "test_scenario_name").await;
+        let fixtures = create_scenario_fixtures_set(&mut pool.get_ok(), "test_scenario_name").await;
 
         let url = scenario_url(
             fixtures.project.id,
@@ -744,7 +750,7 @@ mod tests {
 
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
-        let exists = Scenario::exists(pool.get_ok().deref_mut(), fixtures.scenario.id)
+        let exists = Scenario::exists(&mut pool.get_ok(), fixtures.scenario.id)
             .await
             .expect("Failed to check if scenario exists");
 
diff --git a/editoast/src/views/search.rs b/editoast/src/views/search.rs
index 536a879835c..0e87250c18a 100644
--- a/editoast/src/views/search.rs
+++ b/editoast/src/views/search.rs
@@ -197,6 +197,8 @@
 
 // TODO: the documentation of this file needs to be updated (no more search.yml)
 
+use std::ops::DerefMut;
+
 use axum::extract::Json;
 use axum::extract::Query;
 use axum::extract::State;
@@ -220,7 +222,6 @@ use serde::Deserialize;
 use serde::Serialize;
 use serde_json::value::Value as JsonValue;
 use std::collections::HashSet;
-use std::ops::DerefMut;
 use utoipa::ToSchema;
 
 use crate::error::Result;
@@ -382,7 +383,7 @@ async fn search(
     }
 
     let objects = query
-        .load::<SearchDBResult>(db_pool.get().await?.deref_mut())
+        .load::<SearchDBResult>(&mut db_pool.get().await?.write().await.deref_mut())
         .await?;
     let results: Vec<_> = objects.into_iter().map(|r| r.result).collect();
     Ok(Json(serde_json::to_value(results).unwrap()))
diff --git a/editoast/src/views/stdcm_search_environment.rs b/editoast/src/views/stdcm_search_environment.rs
index 7801172e35e..7fce866ed6e 100644
--- a/editoast/src/views/stdcm_search_environment.rs
+++ b/editoast/src/views/stdcm_search_environment.rs
@@ -160,7 +160,6 @@ pub mod test {
     use chrono::NaiveDate;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::modelsv2::stdcm_search_environment::test::stdcm_search_env_fixtures;
@@ -174,7 +173,7 @@ pub mod test {
         let pool = app.db_pool();
 
         let (infra, timetable, work_schedule_group, electrical_profile_set) =
-            stdcm_search_env_fixtures(pool.get_ok().deref_mut()).await;
+            stdcm_search_env_fixtures(&mut pool.get_ok()).await;
 
         let form = StdcmSearchEnvironmentCreateForm {
             infra_id: infra.id,
@@ -195,7 +194,7 @@ pub mod test {
 
         // THEN
         let stdcm_search_env_in_db =
-            StdcmSearchEnvironment::retrieve(pool.get_ok().deref_mut(), stdcm_search_env.id)
+            StdcmSearchEnvironment::retrieve(&mut pool.get_ok(), stdcm_search_env.id)
                 .await
                 .expect("Failed to retrieve stdcm search environment")
                 .expect("Stdcm search environment not found");
@@ -208,12 +207,12 @@ pub mod test {
         let app = TestAppBuilder::default_app();
 
         let pool = app.db_pool();
-        StdcmSearchEnvironment::delete_all(pool.get_ok().deref_mut())
+        StdcmSearchEnvironment::delete_all(&mut pool.get_ok())
             .await
             .expect("failed to delete envs");
 
         let (infra, timetable, work_schedule_group, electrical_profile_set) =
-            stdcm_search_env_fixtures(pool.get_ok().deref_mut()).await;
+            stdcm_search_env_fixtures(&mut pool.get_ok()).await;
 
         let begin = NaiveDate::from_ymd_opt(2024, 1, 1).unwrap().into();
         let end = NaiveDate::from_ymd_opt(2024, 1, 15).unwrap().into();
@@ -225,7 +224,7 @@ pub mod test {
             .timetable_id(timetable.id)
             .search_window_begin(begin)
             .search_window_end(end)
-            .create(pool.get_ok().deref_mut())
+            .create(&mut pool.get_ok())
             .await
             .expect("Failed to create stdcm search environment");
 
@@ -257,7 +256,7 @@ pub mod test {
         // GIVEN
         let app = TestAppBuilder::default_app();
 
-        let _ = StdcmSearchEnvironment::delete_all(app.db_pool().get_ok().deref_mut()).await;
+        let _ = StdcmSearchEnvironment::delete_all(&mut app.db_pool().get_ok()).await;
 
         let request = app.get("/stdcm/search_environment");
 
diff --git a/editoast/src/views/study.rs b/editoast/src/views/study.rs
index 470611db454..aac9f419d39 100644
--- a/editoast/src/views/study.rs
+++ b/editoast/src/views/study.rs
@@ -1,5 +1,3 @@
-use std::ops::DerefMut as _;
-
 use axum::extract::Json;
 use axum::extract::Path;
 use axum::extract::Query;
@@ -10,7 +8,6 @@ use chrono::NaiveDate;
 use chrono::Utc;
 use derivative::Derivative;
 use diesel_async::scoped_futures::ScopedFutureExt;
-use diesel_async::AsyncConnection;
 use editoast_authz::BuiltinRole;
 use editoast_derive::EditoastError;
 use editoast_models::DbConnection;
@@ -150,22 +147,25 @@ async fn create(
         return Err(AuthorizationError::Unauthorized.into());
     }
 
-    let conn = &mut db_pool.get().await?;
+    let connection = db_pool.get().await?;
 
-    let (study, project) = conn
+    let (study, project) = connection
         .transaction::<_, InternalError, _>(|conn| {
-            async {
+            async move {
                 // Check if project exists
-                let mut project = Project::retrieve_or_fail(conn, project_id, || {
+                let mut project = Project::retrieve_or_fail(&mut conn.clone(), project_id, || {
                     ProjectError::NotFound { project_id }
                 })
                 .await?;
 
                 // Create study
-                let study: Study = data.into_study_changeset(project_id)?.create(conn).await?;
+                let study: Study = data
+                    .into_study_changeset(project_id)?
+                    .create(&mut conn.clone())
+                    .await?;
 
                 // Update project last_modification field
-                project.update_last_modified(conn).await?;
+                project.update_last_modified(&mut conn.clone()).await?;
 
                 Ok((study, project))
             }
@@ -332,12 +332,12 @@ async fn patch(
     if !authorized {
         return Err(AuthorizationError::Unauthorized.into());
     }
-    let conn = &mut db_pool.get().await?;
-    let (study_scenarios, project) = conn
+    let connection = db_pool.get().await?;
+    let (study_scenarios, project) = connection
         .transaction::<_, InternalError, _>(|conn| {
-            async {
+            async move {
                 // Check if project exists
-                let mut project = Project::retrieve_or_fail(conn, project_id, || {
+                let mut project = Project::retrieve_or_fail(&mut conn.clone(), project_id, || {
                     ProjectError::NotFound { project_id }
                 })
                 .await?;
@@ -346,12 +346,15 @@ async fn patch(
                 let study = data
                     .into_study_changeset()?
                     .last_modification(Utc::now().naive_utc())
-                    .update_or_fail(conn, study_id, || StudyError::NotFound { study_id })
+                    .update_or_fail(&mut conn.clone(), study_id, || StudyError::NotFound {
+                        study_id,
+                    })
                     .await?;
-                let study_scenarios = StudyWithScenarioCount::try_fetch(conn, study).await?;
+                let study_scenarios =
+                    StudyWithScenarioCount::try_fetch(&mut conn.clone(), study).await?;
 
                 // Update project last_modification field
-                project.update_last_modified(conn).await?;
+                project.update_last_modified(&mut conn.clone()).await?;
 
                 Ok((study_scenarios, project))
             }
@@ -414,7 +417,7 @@ async fn list(
     }
 
     let ordering = ordering_params.ordering;
-    if !Project::exists(db_pool.get().await?.deref_mut(), project_id).await? {
+    if !Project::exists(&mut db_pool.get().await?, project_id).await? {
         return Err(ProjectError::NotFound { project_id }.into());
     }
 
@@ -425,13 +428,12 @@ async fn list(
         .filter(move || Study::PROJECT_ID.eq(project_id))
         .order_by(move || ordering.as_study_ordering());
 
-    let (studies, stats) =
-        Study::list_paginated(db_pool.get().await?.deref_mut(), settings).await?;
+    let (studies, stats) = Study::list_paginated(&mut db_pool.get().await?, settings).await?;
     let results = studies
         .into_iter()
         .zip(db_pool.iter_conn())
         .map(|(project, conn)| async move {
-            StudyWithScenarioCount::try_fetch(conn.await?.deref_mut(), project).await
+            StudyWithScenarioCount::try_fetch(&mut conn.await?, project).await
         });
     let results = futures::future::try_join_all(results).await?;
 
@@ -456,8 +458,7 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
         let request = app
             .post(&format!("/projects/{}/studies/", created_project.id))
@@ -471,7 +472,7 @@ pub mod test {
             }));
         let response: StudyResponse = app.fetch(request).assert_status(StatusCode::OK).json_into();
 
-        let study = Study::retrieve(db_pool.get_ok().deref_mut(), response.study.id)
+        let study = Study::retrieve(&mut db_pool.get_ok(), response.study.id)
             .await
             .expect("Failed to retrieve study")
             .expect("Study not found");
@@ -485,15 +486,10 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
-        let created_study = create_study(
-            db_pool.get_ok().deref_mut(),
-            "test_study_name",
-            created_project.id,
-        )
-        .await;
+        let created_study =
+            create_study(&mut db_pool.get_ok(), "test_study_name", created_project.id).await;
 
         let request = app.get(&format!("/projects/{}/studies/", created_project.id));
 
@@ -514,15 +510,10 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
-        let created_study = create_study(
-            db_pool.get_ok().deref_mut(),
-            "test_study_name",
-            created_project.id,
-        )
-        .await;
+        let created_study =
+            create_study(&mut db_pool.get_ok(), "test_study_name", created_project.id).await;
 
         let request = app.get(&format!(
             "/projects/{}/studies/{}",
@@ -541,15 +532,10 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
-        let created_study = create_study(
-            db_pool.get_ok().deref_mut(),
-            "test_study_name",
-            created_project.id,
-        )
-        .await;
+        let created_study =
+            create_study(&mut db_pool.get_ok(), "test_study_name", created_project.id).await;
 
         let request = app.get(&format!(
             "/projects/{}/studies/{}",
@@ -565,15 +551,10 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
-        let created_study = create_study(
-            db_pool.get_ok().deref_mut(),
-            "test_study_name",
-            created_project.id,
-        )
-        .await;
+        let created_study =
+            create_study(&mut db_pool.get_ok(), "test_study_name", created_project.id).await;
 
         let request = app.delete(&format!(
             "/projects/{}/studies/{}",
@@ -582,7 +563,7 @@ pub mod test {
 
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
-        let exists = Study::exists(db_pool.get_ok().deref_mut(), created_study.id)
+        let exists = Study::exists(&mut db_pool.get_ok(), created_study.id)
             .await
             .expect("Failed to check if study exists");
 
@@ -594,15 +575,10 @@ pub mod test {
         let app = TestAppBuilder::default_app();
         let db_pool = app.db_pool();
 
-        let created_project =
-            create_project(db_pool.get_ok().deref_mut(), "test_project_name").await;
+        let created_project = create_project(&mut db_pool.get_ok(), "test_project_name").await;
 
-        let created_study = create_study(
-            db_pool.get_ok().deref_mut(),
-            "test_study_name",
-            created_project.id,
-        )
-        .await;
+        let created_study =
+            create_study(&mut db_pool.get_ok(), "test_study_name", created_project.id).await;
 
         let study_name = "rename_test";
         let study_budget = 20000;
@@ -619,12 +595,12 @@ pub mod test {
 
         app.fetch(request).assert_status(StatusCode::OK);
 
-        let updated_study = Study::retrieve(db_pool.get_ok().deref_mut(), created_study.id)
+        let updated_study = Study::retrieve(&mut db_pool.get_ok(), created_study.id)
             .await
             .expect("Failed to retrieve study")
             .expect("Study not found");
 
-        let updated_project = Project::retrieve(db_pool.get_ok().deref_mut(), created_project.id)
+        let updated_project = Project::retrieve(&mut db_pool.get_ok(), created_project.id)
             .await
             .expect("Failed to retrieve project")
             .expect("Project not found");
diff --git a/editoast/src/views/timetable.rs b/editoast/src/views/timetable.rs
index 24aab70e3fb..6d7078b92d1 100644
--- a/editoast/src/views/timetable.rs
+++ b/editoast/src/views/timetable.rs
@@ -1,7 +1,6 @@
 pub mod stdcm;
 
 use std::collections::HashMap;
-use std::ops::DerefMut as _;
 
 use axum::extract::Json;
 use axum::extract::Path;
@@ -296,24 +295,23 @@ async fn conflicts(
     let electrical_profile_set_id = electrical_profile_set_id_query.electrical_profile_set_id;
 
     // 1. Retrieve Timetable / Infra / Trains / Simultion
-    let timetable_trains = TimetableWithTrains::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
-        timetable_id,
-        || TimetableError::NotFound { timetable_id },
-    )
-    .await?;
+    let timetable_trains =
+        TimetableWithTrains::retrieve_or_fail(&mut db_pool.get().await?, timetable_id, || {
+            TimetableError::NotFound { timetable_id }
+        })
+        .await?;
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         TimetableError::InfraNotFound { infra_id }
     })
     .await?;
 
     let (trains, _): (Vec<_>, _) =
-        TrainSchedule::retrieve_batch(db_pool.get().await?.deref_mut(), timetable_trains.train_ids)
+        TrainSchedule::retrieve_batch(&mut db_pool.get().await?, timetable_trains.train_ids)
             .await?;
 
     let simulations = train_simulation_batch(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         redis_client.clone(),
         core_client.clone(),
         &trains,
@@ -365,7 +363,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
 
         let request = app.get(&format!("/timetable/{}", timetable.id));
 
@@ -400,7 +398,7 @@ mod tests {
             app.fetch(request).assert_status(StatusCode::OK).json_into();
 
         let retrieved_timetable =
-            Timetable::retrieve(pool.get_ok().deref_mut(), created_timetable.timetable_id)
+            Timetable::retrieve(&mut pool.get_ok(), created_timetable.timetable_id)
                 .await
                 .expect("Failed to retrieve timetable")
                 .expect("Timetable not found");
@@ -413,13 +411,13 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
 
         let request = app.delete(format!("/timetable/{}", timetable.id).as_str());
 
         app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
-        let exists = Timetable::exists(pool.get_ok().deref_mut(), timetable.id)
+        let exists = Timetable::exists(&mut pool.get_ok(), timetable.id)
             .await
             .expect("Failed to check if timetable exists");
 
diff --git a/editoast/src/views/timetable/stdcm.rs b/editoast/src/views/timetable/stdcm.rs
index 4b3d7b1cf58..804f520728c 100644
--- a/editoast/src/views/timetable/stdcm.rs
+++ b/editoast/src/views/timetable/stdcm.rs
@@ -7,6 +7,9 @@ use chrono::Utc;
 use chrono::{DateTime, Duration, NaiveDateTime, TimeZone};
 use editoast_authz::BuiltinRole;
 use editoast_derive::EditoastError;
+use editoast_models::DbConnection;
+use editoast_models::DbConnectionPoolV2;
+use editoast_schemas::primitives::PositiveDuration;
 use editoast_schemas::train_schedule::PathItemLocation;
 use editoast_schemas::train_schedule::{Comfort, Margins, PathItem};
 use editoast_schemas::train_schedule::{MarginValue, ScheduleItem};
@@ -14,7 +17,6 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::cmp::max;
 use std::collections::HashMap;
-use std::ops::DerefMut;
 use std::sync::Arc;
 use thiserror::Error;
 use utoipa::IntoParams;
@@ -44,9 +46,6 @@ use crate::AppState;
 use crate::RedisClient;
 use crate::Retrieve;
 use crate::RetrieveBatch;
-use editoast_models::DbConnection;
-use editoast_models::DbConnectionPoolV2;
-use editoast_schemas::primitives::PositiveDuration;
 
 crate::routes! {
     "/stdcm" => stdcm,
@@ -164,39 +163,35 @@ async fn stdcm(
     }
 
     let db_pool = app_state.db_pool_v2.clone();
+    let conn = &mut db_pool.get().await?;
+
     let redis_client = app_state.redis.clone();
     let core_client = app_state.core_client.clone();
     let timetable_id = id;
     let infra_id = query.infra;
 
     // 1. Retrieve Timetable / Infra / Trains / Simulation / Rolling Stock
-    let timetable_trains = TimetableWithTrains::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
-        timetable_id,
-        || STDCMError::TimetableNotFound { timetable_id },
-    )
-    .await?;
-
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
-        STDCMError::InfraNotFound { infra_id }
+    let timetable_trains = TimetableWithTrains::retrieve_or_fail(conn, timetable_id, || {
+        STDCMError::TimetableNotFound { timetable_id }
     })
     .await?;
 
+    let infra =
+        Infra::retrieve_or_fail(conn, infra_id, || STDCMError::InfraNotFound { infra_id }).await?;
+
     let (trains, _): (Vec<_>, _) =
-        TrainSchedule::retrieve_batch(db_pool.get().await?.deref_mut(), timetable_trains.train_ids)
-            .await?;
-
-    let rolling_stock = RollingStockModel::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
-        stdcm_request.rolling_stock_id,
-        || STDCMError::RollingStockNotFound {
-            rolling_stock_id: stdcm_request.rolling_stock_id,
-        },
-    )
-    .await?;
+        TrainSchedule::retrieve_batch(conn, timetable_trains.train_ids).await?;
+
+    let rolling_stock =
+        RollingStockModel::retrieve_or_fail(conn, stdcm_request.rolling_stock_id, || {
+            STDCMError::RollingStockNotFound {
+                rolling_stock_id: stdcm_request.rolling_stock_id,
+            }
+        })
+        .await?;
 
     let simulations = train_simulation_batch(
-        db_pool.get().await?.deref_mut(),
+        conn,
         redis_client.clone(),
         core_client.clone(),
         &trains,
@@ -247,8 +242,7 @@ async fn stdcm(
         build_train_requirements(trains, simulations, departure_time, latest_simulation_end);
 
     // 4. Parse stdcm path items
-    let path_items =
-        parse_stdcm_steps(db_pool.get().await?.deref_mut(), &stdcm_request, &infra).await?;
+    let path_items = parse_stdcm_steps(conn, &stdcm_request, &infra).await?;
 
     // 5. Build STDCM request
     let stdcm_response = STDCMRequest {
@@ -273,7 +267,7 @@ async fn stdcm(
         work_schedules: match stdcm_request.work_schedule_group_id {
             Some(work_schedule_group_id) => {
                 build_work_schedules(
-                    db_pool.get().await?.deref_mut(),
+                    conn,
                     departure_time,
                     maximum_departure_delay,
                     maximum_run_time,
@@ -488,7 +482,7 @@ async fn get_simulation_run_time(
     };
 
     let (sim_result, _) = train_simulation(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         redis_client,
         core_client,
         train_schedule,
diff --git a/editoast/src/views/train_schedule.rs b/editoast/src/views/train_schedule.rs
index bec575e5065..56161bab74e 100644
--- a/editoast/src/views/train_schedule.rs
+++ b/editoast/src/views/train_schedule.rs
@@ -5,7 +5,6 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::hash::Hash;
 use std::hash::Hasher;
-use std::ops::DerefMut;
 use std::sync::Arc;
 
 use axum::extract::Json;
@@ -356,22 +355,21 @@ async fn simulation(
     let train_schedule_id = train_schedule_id.id;
 
     // Retrieve infra or fail
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         TrainScheduleError::InfraNotFound { infra_id }
     })
     .await?;
 
     // Retrieve train_schedule or fail
-    let train_schedule = TrainSchedule::retrieve_or_fail(
-        db_pool.get().await?.deref_mut(),
-        train_schedule_id,
-        || TrainScheduleError::NotFound { train_schedule_id },
-    )
-    .await?;
+    let train_schedule =
+        TrainSchedule::retrieve_or_fail(&mut db_pool.get().await?, train_schedule_id, || {
+            TrainScheduleError::NotFound { train_schedule_id }
+        })
+        .await?;
 
     Ok(Json(
         train_simulation(
-            db_pool.get().await?.deref_mut(),
+            &mut db_pool.get().await?,
             redis_client,
             core_client,
             train_schedule,
@@ -685,24 +683,24 @@ async fn simulation_summary(
     }
 
     let db_pool = app_state.db_pool_v2.clone();
+    let conn = &mut db_pool.get().await?;
     let redis_client = app_state.redis.clone();
     let core = app_state.core_client.clone();
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
-        TrainScheduleError::InfraNotFound { infra_id }
+    let infra = Infra::retrieve_or_fail(conn, infra_id, || TrainScheduleError::InfraNotFound {
+        infra_id,
     })
     .await?;
-    let train_schedules: Vec<TrainSchedule> = TrainSchedule::retrieve_batch_or_fail(
-        db_pool.get().await?.deref_mut(),
-        train_schedule_ids,
-        |missing| TrainScheduleError::BatchTrainScheduleNotFound {
-            number: missing.len(),
-        },
-    )
-    .await?;
+    let train_schedules: Vec<TrainSchedule> =
+        TrainSchedule::retrieve_batch_or_fail(conn, train_schedule_ids, |missing| {
+            TrainScheduleError::BatchTrainScheduleNotFound {
+                number: missing.len(),
+            }
+        })
+        .await?;
 
     let simulations = train_simulation_batch(
-        db_pool.get().await?.deref_mut(),
+        conn,
         redis_client,
         core,
         &train_schedules,
@@ -805,8 +803,6 @@ async fn get_path(
 
 #[cfg(test)]
 mod tests {
-    use std::ops::DerefMut;
-
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
     use rstest::rstest;
@@ -827,9 +823,8 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
-        let train_schedule =
-            create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
+        let train_schedule = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
 
         let url = format!("/train_schedule/{}", train_schedule.id);
         let request = app.get(&url);
@@ -852,10 +847,10 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
-        let ts1 = create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
-        let ts2 = create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
-        let ts3 = create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
+        let ts1 = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
+        let ts2 = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
+        let ts3 = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
 
         // Should succeed
         let request = app.post("/train_schedule").json(&json!({
@@ -871,7 +866,7 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
         let train_schedule_base = simple_train_schedule_base();
 
         // Insert train_schedule
@@ -889,9 +884,8 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
-        let train_schedule =
-            create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
+        let train_schedule = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
 
         let request = app
             .delete("/train_schedule/")
@@ -899,7 +893,7 @@ mod tests {
 
         let _ = app.fetch(request).assert_status(StatusCode::NO_CONTENT);
 
-        let exists = TrainSchedule::exists(pool.get_ok().deref_mut(), train_schedule.id)
+        let exists = TrainSchedule::exists(&mut pool.get_ok(), train_schedule.id)
             .await
             .expect("Failed to retrieve train_schedule");
 
@@ -911,9 +905,8 @@ mod tests {
         let app = TestAppBuilder::default_app();
         let pool = app.db_pool();
 
-        let timetable = create_timetable(pool.get_ok().deref_mut()).await;
-        let train_schedule =
-            create_simple_train_schedule(pool.get_ok().deref_mut(), timetable.id).await;
+        let timetable = create_timetable(&mut pool.get_ok()).await;
+        let train_schedule = create_simple_train_schedule(&mut pool.get_ok(), timetable.id).await;
 
         let mut update_train_schedule_base = simple_train_schedule_base();
         update_train_schedule_base.rolling_stock_name = String::from("NEW ROLLING_STOCK");
@@ -998,11 +991,10 @@ mod tests {
             .db_pool(db_pool.clone())
             .core_client(core.into())
             .build();
-        let small_infra = create_small_infra(db_pool.get_ok().deref_mut()).await;
+        let small_infra = create_small_infra(&mut db_pool.get_ok()).await;
         let rolling_stock =
-            create_fast_rolling_stock(db_pool.get_ok().deref_mut(), "simulation_rolling_stock")
-                .await;
-        let timetable = create_timetable(db_pool.get_ok().deref_mut()).await;
+            create_fast_rolling_stock(&mut db_pool.get_ok(), "simulation_rolling_stock").await;
+        let timetable = create_timetable(&mut db_pool.get_ok()).await;
         let train_schedule_base: TrainScheduleBase = TrainScheduleBase {
             rolling_stock_name: rolling_stock.name.clone(),
             ..serde_json::from_str(include_str!("../tests/train_schedules/simple.json"))
@@ -1014,7 +1006,7 @@ mod tests {
         }
         .into();
         let train_schedule = train_schedule
-            .create(db_pool.get_ok().deref_mut())
+            .create(&mut db_pool.get_ok())
             .await
             .expect("Failed to create train schedule");
         (app, small_infra.id, train_schedule.id)
diff --git a/editoast/src/views/train_schedule/projection.rs b/editoast/src/views/train_schedule/projection.rs
index ff98d812433..6645bc9e5b0 100644
--- a/editoast/src/views/train_schedule/projection.rs
+++ b/editoast/src/views/train_schedule/projection.rs
@@ -13,7 +13,6 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::hash::Hash;
 use std::hash::Hasher;
-use std::ops::DerefMut;
 use std::sync::Arc;
 use tracing::info;
 use utoipa::ToSchema;
@@ -162,22 +161,21 @@ async fn project_path(
     let path_projection = PathProjection::new(&path_track_ranges);
     let mut redis_conn = redis_client.get_connection().await?;
 
-    let infra = Infra::retrieve_or_fail(db_pool.get().await?.deref_mut(), infra_id, || {
+    let infra = Infra::retrieve_or_fail(&mut db_pool.get().await?, infra_id, || {
         TrainScheduleError::InfraNotFound { infra_id }
     })
     .await?;
 
-    let trains: Vec<TrainSchedule> = TrainSchedule::retrieve_batch_or_fail(
-        db_pool.get().await?.deref_mut(),
-        train_ids,
-        |missing| TrainScheduleError::BatchTrainScheduleNotFound {
-            number: missing.len(),
-        },
-    )
-    .await?;
+    let trains: Vec<TrainSchedule> =
+        TrainSchedule::retrieve_batch_or_fail(&mut db_pool.get().await?, train_ids, |missing| {
+            TrainScheduleError::BatchTrainScheduleNotFound {
+                number: missing.len(),
+            }
+        })
+        .await?;
 
     let (rolling_stocks, _): (Vec<_>, _) = RollingStockModel::retrieve_batch(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         trains
             .iter()
             .map::<String, _>(|t| t.rolling_stock_name.clone()),
@@ -185,7 +183,7 @@ async fn project_path(
     .await?;
 
     let simulations = train_simulation_batch(
-        db_pool.get().await?.deref_mut(),
+        &mut db_pool.get().await?,
         redis_client.clone(),
         core_client.clone(),
         &trains,
diff --git a/editoast/src/views/work_schedules.rs b/editoast/src/views/work_schedules.rs
index a8fb45db891..656178cb86f 100644
--- a/editoast/src/views/work_schedules.rs
+++ b/editoast/src/views/work_schedules.rs
@@ -181,7 +181,6 @@ pub mod test {
     use pretty_assertions::assert_eq;
     use rstest::rstest;
     use serde_json::json;
-    use std::ops::DerefMut;
 
     use super::*;
     use crate::views::test_app::TestAppBuilder;
@@ -211,7 +210,7 @@ pub mod test {
 
         // THEN
         let created_group = WorkScheduleGroup::retrieve(
-            pool.get_ok().deref_mut(),
+            &mut pool.get_ok(),
             work_schedule_response.work_schedule_group_id,
         )
         .await
@@ -247,7 +246,7 @@ pub mod test {
         WorkScheduleGroup::changeset()
             .name("duplicated work schedule group name".to_string())
             .creation_date(Utc::now().naive_utc())
-            .create(pool.get_ok().deref_mut())
+            .create(&mut pool.get_ok())
             .await
             .expect("Failed to create work schedule group");