diff --git a/server/tests/adresar/delete_adresar_test.rs b/server/tests/adresar/delete_adresar_test.rs
index 0d0d2e4..2a25a5f 100644
--- a/server/tests/adresar/delete_adresar_test.rs
+++ b/server/tests/adresar/delete_adresar_test.rs
@@ -5,6 +5,13 @@ use common::proto::multieko2::adresar::DeleteAdresarRequest;
 use crate::common::setup_test_db;
 use sqlx::PgPool;
 use tonic;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+// Reuse the mutex from get_adresar_by_position_test or create a new one
+lazy_static::lazy_static! {
+    static ref TEST_MUTEX: Arc<Mutex<()>> = Arc::new(Mutex::new(()));
+}
 
 // Fixtures
 #[fixture]
@@ -20,37 +27,45 @@ async fn closed_pool(#[future] pool: PgPool) -> PgPool {
 }
 
 #[fixture]
-async fn existing_record(#[future] pool: PgPool) -> (PgPool, i64) {
+async fn existing_record(#[future] pool: PgPool) -> (PgPool, i64, String) {
     let pool = pool.await;
+    // Use a unique prefix for test data
+    let prefix = format!("DeleteTest_{}", chrono::Utc::now().timestamp_nanos());
+
     let record = sqlx::query!(
         r#"
         INSERT INTO adresar (firma, deleted)
-        VALUES ('Test Company', false)
+        VALUES ($1, false)
         RETURNING id
-        "#
+        "#,
+        format!("{}_Company", prefix)
     )
     .fetch_one(&pool)
     .await
     .unwrap();
 
-    (pool, record.id)
+    (pool, record.id, prefix)
 }
 
 #[fixture]
-async fn existing_deleted_record(#[future] pool: PgPool) -> (PgPool, i64) {
+async fn existing_deleted_record(#[future] pool: PgPool) -> (PgPool, i64, String) {
     let pool = pool.await;
+    // Use a unique prefix for test data
+    let prefix = format!("DeletedTest_{}", chrono::Utc::now().timestamp_nanos());
+
     let record = sqlx::query!(
         r#"
         INSERT INTO adresar (firma, deleted)
-        VALUES ('Deleted Company', true)
+        VALUES ($1, true)
         RETURNING id
-        "#
+        "#,
+        format!("{}_Deleted", prefix)
     )
     .fetch_one(&pool)
     .await
     .unwrap();
 
-    (pool, record.id)
+    (pool, record.id, prefix)
 }
 
 // Helper to check if the record is deleted
@@ -63,18 +78,37 @@ async fn assert_record_deleted(pool: &PgPool, id: i64) {
     assert!(db_record.deleted);
 }
 
+// Helper to clean up test records
+async fn cleanup_test_records(pool: &PgPool, prefix: &str) {
+    if !prefix.is_empty() {
+        sqlx::query!(
+            "DELETE FROM adresar WHERE firma LIKE $1",
+            format!("{}%", prefix)
+        )
+        .execute(pool)
+        .await
+        .unwrap();
+    }
+}
+
 // Tests
 #[rstest]
 #[tokio::test]
 async fn test_delete_adresar_success(
-    #[future] existing_record: (PgPool, i64),
+    #[future] existing_record: (PgPool, i64, String),
 ) {
-    let (pool, id) = existing_record.await;
+    // Take a lock to prevent concurrent test execution
+    let _guard = TEST_MUTEX.lock().await;
+
+    let (pool, id, prefix) = existing_record.await;
     let request = DeleteAdresarRequest { id };
     let response = delete_adresar(&pool, request).await.unwrap();
 
     assert!(response.success);
     assert_record_deleted(&pool, id).await;
+
+    // Clean up
+    cleanup_test_records(&pool, &prefix).await;
 }
 
 #[rstest]
@@ -82,6 +116,9 @@ async fn test_delete_adresar_success(
 async fn test_delete_adresar_nonexistent_id(
     #[future] pool: PgPool,
 ) {
+    // Take a lock to prevent concurrent test execution
+    let _guard = TEST_MUTEX.lock().await;
+
     let pool = pool.await;
     let request = DeleteAdresarRequest { id: 9999 };
     let response = delete_adresar(&pool, request).await.unwrap();
@@ -93,14 +130,20 @@ async fn test_delete_adresar_nonexistent_id(
 #[rstest]
 #[tokio::test]
 async fn test_delete_adresar_already_deleted(
-    #[future] existing_deleted_record: (PgPool, i64),
+    #[future] existing_deleted_record: (PgPool, i64, String),
 ) {
-    let (pool, id) = existing_deleted_record.await;
+    // Take a lock to prevent concurrent test execution
+    let _guard = TEST_MUTEX.lock().await;
+
+    let (pool, id, prefix) = existing_deleted_record.await;
     let request = DeleteAdresarRequest { id };
     let response = delete_adresar(&pool, request).await.unwrap();
 
     // Deleting an already deleted record should return success: false
     assert!(!response.success);
+
+    // Clean up
+    cleanup_test_records(&pool, &prefix).await;
 }
 
 #[rstest]
@@ -108,6 +151,7 @@ async fn test_delete_adresar_already_deleted(
 async fn test_delete_adresar_database_error(
     #[future] closed_pool: PgPool,
 ) {
+    // No need for mutex here as we're not modifying the database
     let closed_pool = closed_pool.await;
     let request = DeleteAdresarRequest { id: 1 };
     let result = delete_adresar(&closed_pool, request).await;