diff --git a/services/backup/src/http/handlers/backup.rs b/services/backup/src/http/handlers/backup.rs
index bdfed2477..9f24f4b84 100644
--- a/services/backup/src/http/handlers/backup.rs
+++ b/services/backup/src/http/handlers/backup.rs
@@ -1,332 +1,331 @@
 use actix_web::{
   error::ErrorBadRequest,
   web::{self, Bytes},
   HttpResponse, Responder,
 };
 use comm_lib::{
   auth::UserIdentity,
   backup::LatestBackupIDResponse,
   blob::{client::BlobServiceClient, types::BlobInfo},
   http::{
     auth_service::Authenticated,
     multipart::{get_named_text_field, get_text_field},
   },
   tools::Defer,
 };
 use std::convert::Infallible;
 use tokio_stream::{wrappers::ReceiverStream, StreamExt};
 use tracing::{info, instrument, trace, warn};
 
+use crate::identity::find_user_id;
 use crate::{
   database::{backup_item::BackupItem, DatabaseClient},
   error::BackupError,
 };
 
 #[instrument(skip_all, fields(backup_id))]
 pub async fn upload(
   user: UserIdentity,
   blob_client: Authenticated<BlobServiceClient>,
   db_client: web::Data<DatabaseClient>,
   mut multipart: actix_multipart::Multipart,
 ) -> actix_web::Result<HttpResponse> {
   let backup_id = get_named_text_field("backup_id", &mut multipart).await?;
   let blob_client = blob_client.with_user_identity(user.clone());
   tracing::Span::current().record("backup_id", &backup_id);
 
   info!("Backup data upload started");
 
   let (user_keys_blob_info, user_keys_revoke) = forward_field_to_blob(
     &mut multipart,
     &blob_client,
     "user_keys_hash",
     "user_keys",
   )
   .await?;
 
   let (user_data_blob_info, user_data_revoke) = forward_field_to_blob(
     &mut multipart,
     &blob_client,
     "user_data_hash",
     "user_data",
   )
   .await?;
 
   let attachments_hashes: Vec<String> =
     match get_text_field(&mut multipart).await? {
       Some((name, attachments)) => {
         if name != "attachments" {
           warn!(
             name,
             "Malformed request: 'attachments' text field expected."
           );
           return Err(ErrorBadRequest("Bad request"));
         }
 
         attachments.lines().map(ToString::to_string).collect()
       }
       None => Vec::new(),
     };
 
   let mut attachments = Vec::new();
   let mut attachments_revokes = Vec::new();
   for attachment_hash in attachments_hashes {
     let (holder, revoke) =
       create_attachment_holder(&attachment_hash, &blob_client).await?;
 
     attachments.push(BlobInfo {
       blob_hash: attachment_hash,
       holder,
     });
     attachments_revokes.push(revoke);
   }
 
   let siwe_backup_msg_option: Option<String> =
     match get_text_field(&mut multipart).await? {
       Some((name, siwe_backup_msg)) => {
         if name == "siwe_backup_msg" {
           Some(siwe_backup_msg)
         } else {
           None
         }
       }
       _ => None,
     };
 
   let item = BackupItem::new(
     user.user_id.clone(),
     backup_id,
     user_keys_blob_info,
     user_data_blob_info,
     attachments,
     siwe_backup_msg_option,
   );
 
   db_client
     .put_backup_item(item)
     .await
     .map_err(BackupError::from)?;
 
   user_keys_revoke.cancel();
   user_data_revoke.cancel();
   for attachment_revoke in attachments_revokes {
     attachment_revoke.cancel();
   }
 
   db_client
     .remove_old_backups(&user.user_id, &blob_client)
     .await
     .map_err(BackupError::from)?;
 
   Ok(HttpResponse::Ok().finish())
 }
 
 #[instrument(skip_all, fields(hash_field_name, data_field_name))]
 async fn forward_field_to_blob<'revoke, 'blob: 'revoke>(
   multipart: &mut actix_multipart::Multipart,
   blob_client: &'blob BlobServiceClient,
   hash_field_name: &str,
   data_field_name: &str,
 ) -> actix_web::Result<(BlobInfo, Defer<'revoke>)> {
   trace!("Reading blob fields: {hash_field_name:?}, {data_field_name:?}");
 
   let blob_hash = get_named_text_field(hash_field_name, multipart).await?;
 
   let Some(mut field) = multipart.try_next().await? else {
     warn!("Malformed request: expected a field.");
     return Err(ErrorBadRequest("Bad request"))?;
   };
   if field.name() != data_field_name {
     warn!(
       hash_field_name,
       "Malformed request: '{data_field_name}' data field expected."
     );
     return Err(ErrorBadRequest("Bad request"))?;
   }
 
   let blob_info = BlobInfo {
     blob_hash,
     holder: uuid::Uuid::new_v4().to_string(),
   };
 
   // [`actix_multipart::Multipart`] isn't [`std::marker::Send`], and so we cannot pass it to the blob client directly.
   // Instead we have to forward it to a channel and create stream from the receiver.
   let (tx, rx) = tokio::sync::mpsc::channel(1);
   let receive_promise = async move {
     trace!("Receiving blob data");
     // [`actix_multipart::MultipartError`] isn't [`std::marker::Send`] so we return it here, and pass [`Infallible`]
     // as the error to the channel
     while let Some(chunk) = field.try_next().await? {
       if let Err(err) = tx.send(Result::<Bytes, Infallible>::Ok(chunk)).await {
         warn!("Error when sending data through a channel: '{err}'");
         // Error here means that the channel has been closed from the blob client side. We don't want to return an error
         // here, because `tokio::try_join!` only returns the first error it receives and we want to prioritize the backup
         // client error.
         break;
       }
     }
     trace!("Finished receiving blob data");
     Result::<(), actix_web::Error>::Ok(())
   };
 
   let data_stream = ReceiverStream::new(rx);
   let send_promise = async {
     blob_client
       .simple_put(&blob_info.blob_hash, &blob_info.holder, data_stream)
       .await
       .map_err(BackupError::from)?;
 
     Ok(())
   };
 
   tokio::try_join!(receive_promise, send_promise)?;
 
   let revoke_info = blob_info.clone();
   let revoke_holder = Defer::new(|| {
     blob_client
       .schedule_revoke_holder(revoke_info.blob_hash, revoke_info.holder)
   });
 
   Ok((blob_info, revoke_holder))
 }
 
 #[instrument(skip_all)]
 async fn create_attachment_holder<'revoke, 'blob: 'revoke>(
   attachment: &str,
   blob_client: &'blob BlobServiceClient,
 ) -> Result<(String, Defer<'revoke>), BackupError> {
   let holder = uuid::Uuid::new_v4().to_string();
 
   if !blob_client
     .assign_holder(attachment, &holder)
     .await
     .map_err(BackupError::from)?
   {
     warn!("Blob attachment with hash {attachment:?} doesn't exist");
   }
 
   let revoke_hash = attachment.to_string();
   let revoke_holder = holder.clone();
   let revoke_holder = Defer::new(|| {
     blob_client.schedule_revoke_holder(revoke_hash, revoke_holder)
   });
 
   Ok((holder, revoke_holder))
 }
 
 #[instrument(skip_all, fields(backup_id = %path))]
 pub async fn download_user_keys(
   user: UserIdentity,
   path: web::Path<String>,
   blob_client: Authenticated<BlobServiceClient>,
   db_client: web::Data<DatabaseClient>,
 ) -> actix_web::Result<HttpResponse> {
   info!("Download user keys request");
   let backup_id = path.into_inner();
   download_user_blob(
     |item| &item.user_keys,
     &user.user_id,
     &backup_id,
     blob_client.into_inner(),
     db_client,
   )
   .await
 }
 
 #[instrument(skip_all, fields(backup_id = %path))]
 pub async fn download_user_data(
   user: UserIdentity,
   path: web::Path<String>,
   blob_client: Authenticated<BlobServiceClient>,
   db_client: web::Data<DatabaseClient>,
 ) -> actix_web::Result<HttpResponse> {
   info!("Download user data request");
   let backup_id = path.into_inner();
   download_user_blob(
     |item| &item.user_data,
     &user.user_id,
     &backup_id,
     blob_client.into_inner(),
     db_client,
   )
   .await
 }
 
 pub async fn download_user_blob(
   data_extractor: impl FnOnce(&BackupItem) -> &BlobInfo,
   user_id: &str,
   backup_id: &str,
   blob_client: BlobServiceClient,
   db_client: web::Data<DatabaseClient>,
 ) -> actix_web::Result<HttpResponse> {
   let backup_item = db_client
     .find_backup_item(user_id, backup_id)
     .await
     .map_err(BackupError::from)?
     .ok_or(BackupError::NoBackup)?;
 
   let stream = blob_client
     .get(&data_extractor(&backup_item).blob_hash)
     .await
     .map_err(BackupError::from)?;
 
   Ok(
     HttpResponse::Ok()
       .content_type("application/octet-stream")
       .streaming(stream),
   )
 }
 
 #[instrument(skip_all, fields(username = %path))]
 pub async fn get_latest_backup_id(
   path: web::Path<String>,
   db_client: web::Data<DatabaseClient>,
 ) -> actix_web::Result<impl Responder> {
   let username = path.into_inner();
-  // Treat username as user_id in the initial version
-  let user_id = username;
+  let user_id = find_user_id(&username).await?;
 
   let Some(backup_item) = db_client
     .find_last_backup_item(&user_id)
     .await
     .map_err(BackupError::from)?
   else {
     return Err(BackupError::NoBackup.into());
   };
 
   let response = LatestBackupIDResponse {
     backup_id: backup_item.backup_id,
     siwe_backup_msg: backup_item.siwe_backup_msg,
   };
 
   Ok(web::Json(response))
 }
 
 #[instrument(skip_all, fields(username = %path))]
 pub async fn download_latest_backup_keys(
   path: web::Path<String>,
   db_client: web::Data<DatabaseClient>,
   blob_client: Authenticated<BlobServiceClient>,
 ) -> actix_web::Result<HttpResponse> {
   let username = path.into_inner();
-  // Treat username as user_id in the initial version
-  let user_id = username;
+  let user_id = find_user_id(&username).await?;
 
   let Some(backup_item) = db_client
     .find_last_backup_item(&user_id)
     .await
     .map_err(BackupError::from)?
   else {
     return Err(BackupError::NoBackup.into());
   };
 
   let stream = blob_client
     .get(&backup_item.user_keys.blob_hash)
     .await
     .map_err(BackupError::from)?;
 
   Ok(
     HttpResponse::Ok()
       .content_type("application/octet-stream")
       .streaming(stream),
   )
 }
diff --git a/services/commtest/tests/backup_integration_test.rs b/services/commtest/tests/backup_integration_test.rs
index 568ec103d..3ad50c9cb 100644
--- a/services/commtest/tests/backup_integration_test.rs
+++ b/services/commtest/tests/backup_integration_test.rs
@@ -1,215 +1,235 @@
 use backup_client::{
   BackupClient, BackupData, BackupDescriptor, DownloadedLog,
   Error as BackupClientError, LogUploadConfirmation, RequestedData, SinkExt,
   StreamExt, TryStreamExt,
 };
 use bytesize::ByteSize;
 use comm_lib::{
   auth::UserIdentity,
   backup::{LatestBackupIDResponse, UploadLogRequest},
 };
 use commtest::identity::device::register_user_device;
 use commtest::{
   service_addr,
   tools::{generate_stable_nbytes, Error},
 };
 use grpc_clients::identity::DeviceType;
 use reqwest::StatusCode;
 use std::collections::HashSet;
 use uuid::Uuid;
 
 #[tokio::test]
 async fn backup_integration_test() -> Result<(), Error> {
   let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
 
   let device_info = register_user_device(None, Some(DeviceType::Ios)).await;
 
   let user_identity = UserIdentity {
     user_id: device_info.user_id.clone(),
     access_token: device_info.access_token,
     device_id: device_info.device_id,
   };
 
   let backup_datas = generate_backup_data();
 
   // Upload backups
   for (backup_data, log_datas) in &backup_datas {
     backup_client
       .upload_backup(&user_identity, backup_data.clone())
       .await?;
 
     let (mut tx, rx) = backup_client.upload_logs(&user_identity).await?;
 
     for log_data in log_datas {
       tx.send(log_data.clone()).await?;
     }
 
     let result: HashSet<LogUploadConfirmation> =
       rx.take(log_datas.len()).try_collect().await?;
     let expected = log_datas
       .iter()
       .map(|data| LogUploadConfirmation {
         backup_id: data.backup_id.clone(),
         log_id: data.log_id,
       })
       .collect();
 
     assert_eq!(result, expected);
   }
 
   // Test direct lookup
   let (backup_data, log_datas) = &backup_datas[1];
 
   let second_backup_descriptor = BackupDescriptor::BackupID {
     backup_id: backup_data.backup_id.clone(),
     user_identity: user_identity.clone(),
   };
 
   let user_keys = backup_client
     .download_backup_data(&second_backup_descriptor, RequestedData::UserKeys)
     .await?;
   assert_eq!(user_keys, backup_data.user_keys);
 
   let user_data = backup_client
     .download_backup_data(&second_backup_descriptor, RequestedData::UserData)
     .await?;
   assert_eq!(user_data, backup_data.user_data);
 
+  // Test latest backup lookup for nonexistent user
+  let latest_backup_descriptor = BackupDescriptor::Latest {
+    username: "nonexistent_user".to_string(),
+  };
+
+  let nonexistent_user_response = backup_client
+    .download_backup_data(&latest_backup_descriptor, RequestedData::BackupID)
+    .await;
+
+  match nonexistent_user_response {
+    Ok(_) => panic!("Expected error, but got success response"),
+    Err(BackupClientError::ReqwestError(error)) => {
+      assert_eq!(
+        error.status(),
+        Some(StatusCode::BAD_REQUEST),
+        "Expected bad request status"
+      );
+    }
+    Err(_) => panic!("Unexpected error type"),
+  }
+
   // Test latest backup lookup
   let latest_backup_descriptor = BackupDescriptor::Latest {
-    // Initial version of the backup service uses `user_id` in place of a username
-    username: device_info.user_id.to_string(),
+    username: device_info.username,
   };
 
   let backup_id_response = backup_client
     .download_backup_data(&latest_backup_descriptor, RequestedData::BackupID)
     .await?;
   let response: LatestBackupIDResponse =
     serde_json::from_slice(&backup_id_response)?;
   assert_eq!(response.backup_id, backup_data.backup_id);
 
   let user_keys = backup_client
     .download_backup_data(&latest_backup_descriptor, RequestedData::UserKeys)
     .await?;
   assert_eq!(user_keys, backup_data.user_keys);
 
   // Test log download
   let log_stream = backup_client
     .download_logs(&user_identity, &backup_data.backup_id)
     .await;
 
   let downloaded_logs: Vec<DownloadedLog> = log_stream.try_collect().await?;
 
   let expected_logs: Vec<DownloadedLog> = log_datas
     .iter()
     .map(|data| DownloadedLog {
       content: data.content.clone(),
       attachments: data.attachments.clone(),
     })
     .collect();
   assert_eq!(downloaded_logs, expected_logs);
 
   // Test backup cleanup
   let (removed_backup, _) = &backup_datas[0];
   let removed_backup_descriptor = BackupDescriptor::BackupID {
     backup_id: removed_backup.backup_id.clone(),
     user_identity: user_identity.clone(),
   };
 
   let response = backup_client
     .download_backup_data(&removed_backup_descriptor, RequestedData::UserKeys)
     .await;
 
   let Err(BackupClientError::ReqwestError(error)) = response else {
     panic!("First backup should have been removed, instead got response: {response:?}");
   };
 
   assert_eq!(
     error.status(),
     Some(StatusCode::NOT_FOUND),
     "Expected status 'not found'"
   );
 
   // Test log cleanup
   let log_stream = backup_client
     .download_logs(&user_identity, &removed_backup.backup_id)
     .await;
 
   let downloaded_logs: Vec<DownloadedLog> = log_stream.try_collect().await?;
 
   if !downloaded_logs.is_empty() {
     panic!(
       "Logs for first backup should have been removed, \
       instead got: {downloaded_logs:?}"
     )
   }
 
   Ok(())
 }
 
 fn generate_backup_data() -> [(BackupData, Vec<UploadLogRequest>); 2] {
   [
     (
       BackupData {
         backup_id: "b1".to_string(),
         user_keys: generate_stable_nbytes(
           ByteSize::kib(4).as_u64() as usize,
           Some(b'a'),
         ),
         user_data: generate_stable_nbytes(
           ByteSize::mib(4).as_u64() as usize,
           Some(b'A'),
         ),
         attachments: vec![],
         siwe_backup_msg: None,
       },
       generate_log_data("b1", b'a'),
     ),
     (
       BackupData {
         backup_id: "b2".to_string(),
         user_keys: generate_stable_nbytes(
           ByteSize::kib(4).as_u64() as usize,
           Some(b'b'),
         ),
         user_data: generate_stable_nbytes(
           ByteSize::mib(4).as_u64() as usize,
           Some(b'B'),
         ),
         attachments: vec![],
         siwe_backup_msg: None,
       },
       generate_log_data("b2", b'b'),
     ),
   ]
 }
 
 fn generate_log_data(backup_id: &str, value: u8) -> Vec<UploadLogRequest> {
   const IN_DB_SIZE: usize = ByteSize::kib(4).as_u64() as usize;
   const IN_BLOB_SIZE: usize = ByteSize::kib(400).as_u64() as usize;
 
   (1..30)
     .map(|log_id| {
       let size = if log_id % 2 == 0 {
         IN_DB_SIZE
       } else {
         IN_BLOB_SIZE
       };
       let attachments = if log_id % 10 == 0 {
         Some(vec![Uuid::new_v4().to_string()])
       } else {
         None
       };
       let mut content = generate_stable_nbytes(size, Some(value));
       let unique_suffix = log_id.to_string();
       content.extend(unique_suffix.as_bytes());
 
       UploadLogRequest {
         backup_id: backup_id.to_string(),
         log_id,
         content,
         attachments,
       }
     })
     .collect()
 }
diff --git a/services/commtest/tests/backup_performance_test.rs b/services/commtest/tests/backup_performance_test.rs
index 522d04b90..c3e7c96a6 100644
--- a/services/commtest/tests/backup_performance_test.rs
+++ b/services/commtest/tests/backup_performance_test.rs
@@ -1,177 +1,188 @@
 use backup_client::{
   BackupClient, BackupData, BackupDescriptor, RequestedData,
 };
 use bytesize::ByteSize;
 use comm_lib::{auth::UserIdentity, backup::LatestBackupIDResponse};
 use commtest::identity::device::register_user_device;
 use commtest::{
   service_addr,
   tools::{generate_stable_nbytes, obtain_number_of_threads, Error},
 };
 use grpc_clients::identity::DeviceType;
 use tokio::{runtime::Runtime, task::JoinSet};
 
 #[tokio::test]
 async fn backup_performance_test() -> Result<(), Error> {
   let backup_client = BackupClient::new(service_addr::BACKUP_SERVICE_HTTP)?;
 
   let number_of_threads = obtain_number_of_threads();
 
   let rt = Runtime::new().unwrap();
 
   println!(
     "Running performance tests for backup, number of threads: {}",
     number_of_threads
   );
 
   let mut backup_data = vec![];
   for i in 0..number_of_threads {
     backup_data.push(BackupData {
       backup_id: format!("b{i}"),
       user_keys: generate_stable_nbytes(
         ByteSize::kib(4).as_u64() as usize,
         Some(i as u8),
       ),
       user_data: generate_stable_nbytes(
         ByteSize::mib(4).as_u64() as usize,
         Some(i as u8),
       ),
       attachments: vec![],
       siwe_backup_msg: None,
     });
   }
 
   let device_info_1 = register_user_device(None, Some(DeviceType::Ios)).await;
   let device_info_2 = register_user_device(None, Some(DeviceType::Ios)).await;
 
   let user_identities = [
     UserIdentity {
       user_id: device_info_1.user_id.clone(),
       access_token: device_info_1.access_token,
       device_id: device_info_1.device_id,
     },
     UserIdentity {
       user_id: device_info_2.user_id.clone(),
       access_token: device_info_2.access_token,
       device_id: device_info_2.device_id,
     },
   ];
 
   tokio::task::spawn_blocking(move || {
     println!("Creating new backups");
     rt.block_on(async {
       let mut set = JoinSet::new();
       for (i, item) in backup_data.iter().cloned().enumerate() {
         let backup_client = backup_client.clone();
         let user = user_identities[i % user_identities.len()].clone();
 
         set.spawn(async move {
           backup_client.upload_backup(&user, item).await.unwrap();
         });
       }
 
       while let Some(result) = set.join_next().await {
         result.unwrap();
       }
     });
 
     let mut latest_ids_for_user = vec![];
     println!("Reading latest ids");
     rt.block_on(async {
       let mut handlers = vec![];
       for user in &user_identities {
         let backup_client = backup_client.clone();
-        let descriptor = BackupDescriptor::Latest {
-          username: user.user_id.clone(),
+
+        let username = if user.user_id == device_info_1.user_id {
+          device_info_1.username.clone()
+        } else {
+          device_info_2.username.clone()
         };
+
+        let descriptor = BackupDescriptor::Latest { username };
+
         handlers.push(tokio::spawn(async move {
           let response = backup_client
             .download_backup_data(&descriptor, RequestedData::BackupID)
             .await
             .unwrap();
 
           serde_json::from_slice::<LatestBackupIDResponse>(&response).unwrap()
         }));
       }
 
       for handler in handlers {
         latest_ids_for_user.push(handler.await.unwrap().backup_id);
       }
     });
 
     assert_eq!(latest_ids_for_user.len(), user_identities.len());
 
     let mut latest_user_keys_for_user = vec![];
     println!("Reading latest user keys");
     rt.block_on(async {
       let mut handlers = vec![];
       for user in &user_identities {
         let backup_client = backup_client.clone();
-        let descriptor = BackupDescriptor::Latest {
-          username: user.user_id.clone(),
+        let username = if user.user_id == device_info_1.user_id {
+          device_info_1.username.clone()
+        } else {
+          device_info_2.username.clone()
         };
+
+        let descriptor = BackupDescriptor::Latest { username };
+
         handlers.push(tokio::spawn(async move {
           backup_client
             .download_backup_data(&descriptor, RequestedData::UserKeys)
             .await
             .unwrap()
         }));
       }
 
       for handler in handlers {
         latest_user_keys_for_user.push(handler.await.unwrap());
       }
     });
 
     assert_eq!(latest_user_keys_for_user.len(), user_identities.len());
     for (backup_id, user_keys) in
       latest_ids_for_user.iter().zip(latest_user_keys_for_user)
     {
       let backup = backup_data
         .iter()
         .find(|data| data.backup_id == *backup_id)
         .expect("Request should return existing backup data");
 
       assert_eq!(backup.user_keys, user_keys);
     }
 
     let mut latest_user_data_for_user = vec![];
     println!("Reading latest user data");
     rt.block_on(async {
       let mut handlers = vec![];
       for (i, backup_id) in latest_ids_for_user.iter().enumerate() {
         let backup_client = backup_client.clone();
         let descriptor = BackupDescriptor::BackupID {
           backup_id: backup_id.clone(),
           user_identity: user_identities[i % user_identities.len()].clone(),
         };
         handlers.push(tokio::spawn(async move {
           backup_client
             .download_backup_data(&descriptor, RequestedData::UserData)
             .await
             .unwrap()
         }));
       }
 
       for handler in handlers {
         latest_user_data_for_user.push(handler.await.unwrap());
       }
     });
 
     assert_eq!(latest_user_data_for_user.len(), user_identities.len());
     for (backup_id, user_data) in
       latest_ids_for_user.iter().zip(latest_user_data_for_user)
     {
       let backup = backup_data
         .iter()
         .find(|data| data.backup_id == *backup_id)
         .expect("Request should return existing backup data");
 
       assert_eq!(backup.user_data, user_data);
     }
   })
   .await
   .expect("Task panicked");
 
   Ok(())
 }