diff --git a/validation/src/upload_mapfix.rs b/validation/src/upload_mapfix.rs
index e943922..17cdca4 100644
--- a/validation/src/upload_mapfix.rs
+++ b/validation/src/upload_mapfix.rs
@@ -3,11 +3,49 @@ use crate::nats_types::UploadMapfixRequest;
 
 #[allow(dead_code)]
 #[derive(Debug)]
-pub enum Error{
+pub enum InnerError{
 	Download(crate::download::Error),
 	IO(std::io::Error),
 	Json(serde_json::Error),
 	Upload(rbx_asset::cookie::UploadError),
+}
+impl std::fmt::Display for InnerError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for InnerError{}
+
+async fn upload_inner(
+	upload_info:UploadMapfixRequest,
+	cloud_context:&rbx_asset::cloud::Context,
+	cookie_context:&rbx_asset::cookie::Context,
+	group_id:Option<u64>,
+)->Result<(),InnerError>{
+	// download the map model
+	let maybe_gzip=download_asset_version(cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
+		asset_id:upload_info.ModelID,
+		version:upload_info.ModelVersion,
+	}).await.map_err(InnerError::Download)?;
+
+	// transparently handle gzipped models
+	let model_data=maybe_gzip.to_vec().map_err(InnerError::IO)?;
+
+	// upload the map to the strafesnet group
+	let _upload_response=cookie_context.upload(rbx_asset::cookie::UploadRequest{
+		assetid:upload_info.TargetAssetID,
+		groupId:group_id,
+		name:None,
+		description:None,
+		ispublic:None,
+		allowComments:None,
+	},model_data).await.map_err(InnerError::Upload)?;
+
+	Ok(())
+}
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum Error{
 	ApiActionMapfixUploaded(tonic::Status),
 }
 impl std::fmt::Display for Error{
@@ -19,29 +57,39 @@ impl std::error::Error for Error{}
 
 impl crate::message_handler::MessageHandler{
 	pub async fn upload_mapfix(&self,upload_info:UploadMapfixRequest)->Result<(),Error>{
-		// download the map model
-		let maybe_gzip=download_asset_version(&self.cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
-			asset_id:upload_info.ModelID,
-			version:upload_info.ModelVersion,
-		}).await.map_err(Error::Download)?;
+		let mapfix_id=upload_info.MapfixID;
+		let result=upload_inner(
+			upload_info,
+			&self.cloud_context,
+			&self.cookie_context,
+			self.group_id,
+		).await;
 
-		// transparently handle gzipped models
-		let model_data=maybe_gzip.to_vec().map_err(Error::IO)?;
+		// update the mapfix depending on the result
+		match result{
+			Ok(())=>{
+				// mark mapfix as uploaded, TargetAssetID is unchanged
+				self.mapfixes.set_status_uploaded(rust_grpc::validator::MapfixId{
+					id:mapfix_id,
+				}).await.map_err(Error::ApiActionMapfixUploaded)?;
+			},
+			Err(e)=>{
+				// log error
+				println!("[upload_mapfix] Error: {e}");
 
-		// upload the map to the strafesnet group
-		let _upload_response=self.cookie_context.upload(rbx_asset::cookie::UploadRequest{
-			assetid:upload_info.TargetAssetID,
-			groupId:self.group_id,
-			name:None,
-			description:None,
-			ispublic:None,
-			allowComments:None,
-		},model_data).await.map_err(Error::Upload)?;
+				self.mapfixes.create_audit_error(
+					rust_grpc::validator::AuditErrorRequest{
+						id:mapfix_id,
+						error_message:e.to_string(),
+					}
+				).await.map_err(Error::ApiActionMapfixUploaded)?;
 
-		// mark mapfix as uploaded, TargetAssetID is unchanged
-		self.mapfixes.set_status_uploaded(rust_grpc::validator::MapfixId{
-			id:upload_info.MapfixID,
-		}).await.map_err(Error::ApiActionMapfixUploaded)?;
+				// update the mapfix model status to accepted
+				self.mapfixes.set_status_not_uploaded(rust_grpc::validator::MapfixId{
+					id:mapfix_id,
+				}).await.map_err(Error::ApiActionMapfixUploaded)?;
+			},
+		}
 
 		Ok(())
 	}
diff --git a/validation/src/upload_submission.rs b/validation/src/upload_submission.rs
index 3b6319d..abd762b 100644
--- a/validation/src/upload_submission.rs
+++ b/validation/src/upload_submission.rs
@@ -3,12 +3,50 @@ use crate::nats_types::UploadSubmissionRequest;
 
 #[allow(dead_code)]
 #[derive(Debug)]
-pub enum Error{
+pub enum InnerError{
 	Download(crate::download::Error),
 	IO(std::io::Error),
 	Json(serde_json::Error),
 	Create(rbx_asset::cookie::CreateError),
 	SystemTime(std::time::SystemTimeError),
+}
+impl std::fmt::Display for InnerError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for InnerError{}
+
+async fn upload_inner(
+	upload_info:UploadSubmissionRequest,
+	cloud_context:&rbx_asset::cloud::Context,
+	cookie_context:&rbx_asset::cookie::Context,
+	group_id:Option<u64>,
+)->Result<u64,InnerError>{
+	// download the map model
+	let maybe_gzip=download_asset_version(cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
+		asset_id:upload_info.ModelID,
+		version:upload_info.ModelVersion,
+	}).await.map_err(InnerError::Download)?;
+
+	// transparently handle gzipped models
+	let model_data=maybe_gzip.to_vec().map_err(InnerError::IO)?;
+
+	// upload the map to the strafesnet group
+	let upload_response=cookie_context.create(rbx_asset::cookie::CreateRequest{
+		name:upload_info.ModelName.clone(),
+		description:"".to_owned(),
+		ispublic:false,
+		allowComments:false,
+		groupId:group_id,
+	},model_data).await.map_err(InnerError::Create)?;
+
+	Ok(upload_response.AssetId)
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum Error{
 	ApiActionSubmissionUploaded(tonic::Status),
 }
 impl std::fmt::Display for Error{
@@ -20,29 +58,40 @@ impl std::error::Error for Error{}
 
 impl crate::message_handler::MessageHandler{
 	pub async fn upload_submission(&self,upload_info:UploadSubmissionRequest)->Result<(),Error>{
-		// download the map model
-		let maybe_gzip=download_asset_version(&self.cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
-			asset_id:upload_info.ModelID,
-			version:upload_info.ModelVersion,
-		}).await.map_err(Error::Download)?;
+		let submission_id=upload_info.SubmissionID;
+		let result=upload_inner(
+			upload_info,
+			&self.cloud_context,
+			&self.cookie_context,
+			self.group_id,
+		).await;
 
-		// transparently handle gzipped models
-		let model_data=maybe_gzip.to_vec().map_err(Error::IO)?;
+		// update the submission depending on the result
+		match result{
+			Ok(uploaded_asset_id)=>{
+				// note the asset id of the created model for later release, and mark the submission as uploaded
+				self.submissions.set_status_uploaded(rust_grpc::validator::StatusUploadedRequest{
+					id:submission_id,
+					uploaded_asset_id,
+				}).await.map_err(Error::ApiActionSubmissionUploaded)?;
+			},
+			Err(e)=>{
+				// log error
+				println!("[upload_submission] Error: {e}");
 
-		// upload the map to the strafesnet group
-		let upload_response=self.cookie_context.create(rbx_asset::cookie::CreateRequest{
-			name:upload_info.ModelName.clone(),
-			description:"".to_owned(),
-			ispublic:false,
-			allowComments:false,
-			groupId:self.group_id,
-		},model_data).await.map_err(Error::Create)?;
+				self.submissions.create_audit_error(
+					rust_grpc::validator::AuditErrorRequest{
+						id:submission_id,
+						error_message:e.to_string(),
+					}
+				).await.map_err(Error::ApiActionSubmissionUploaded)?;
 
-		// note the asset id of the created model for later release, and mark the submission as uploaded
-		self.submissions.set_status_uploaded(rust_grpc::validator::StatusUploadedRequest{
-			id:upload_info.SubmissionID,
-			uploaded_asset_id:upload_response.AssetId,
-		}).await.map_err(Error::ApiActionSubmissionUploaded)?;
+				// update the submission model status to accepted
+				self.submissions.set_status_not_uploaded(rust_grpc::validator::SubmissionId{
+					id:submission_id,
+				}).await.map_err(Error::ApiActionSubmissionUploaded)?;
+			},
+		}
 
 		Ok(())
 	}