diff --git a/server/api/submit.go b/server/api/submit.go
index 8f46d31..0012f39 100644
--- a/server/api/submit.go
+++ b/server/api/submit.go
@@ -18,7 +18,7 @@ func SubmitRestHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-  err := r.ParseMultipartForm(viper.GetInt64("web.maxfilesizemb") * 1024 * 1024)
+	err := r.ParseMultipartForm(viper.GetInt64("web.maxfilesizemb") * 1024 * 1024)
 	if err != nil {
 		slog.Error("Error parsing form in SubmitRestHandler", "error", err)
 		utils.WriteJSONError(w, err.Error(), http.StatusBadRequest)
@@ -40,18 +40,18 @@ func SubmitRestHandler(w http.ResponseWriter, r *http.Request) {
 	file, err := database.CreateFile(r.Context(), fileHeader.Filename, fileBytes)
 	if err != nil {
 		slog.Error("Error saving file in SubmitRestHandler", "error", err)
-    utils.WriteJSONError(w, err.Error(), http.StatusInternalServerError)
+		utils.WriteJSONError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-  err = processing.Submit(r.Context(), file.ID)
-  w.Header().Set("Content-Type", "application/json")
-  enc := json.NewEncoder(w)
-  enc.SetIndent("", "  ")
-  w.WriteHeader(http.StatusOK)
-  err = enc.Encode(file)
+	err = processing.Submit(r.Context(), file.ID)
+	w.Header().Set("Content-Type", "application/json")
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	w.WriteHeader(http.StatusOK)
+	err = enc.Encode(file)
 	if err != nil {
 		slog.Error("Error creating json encoder in SubmitRestHandler", "error", err)
-    utils.WriteJSONError(w, err.Error(), http.StatusInternalServerError)
+		utils.WriteJSONError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
diff --git a/server/internal/config/config.go b/server/internal/config/config.go
index 57568c6..0069c45 100644
--- a/server/internal/config/config.go
+++ b/server/internal/config/config.go
@@ -37,17 +37,17 @@ func setDefaults() {
 	viper.SetDefault("web.key", "/etc/ssl/key/ssl-cert-snakeoil.key")
 	viper.SetDefault("web.loghttp", true)
 	viper.SetDefault("web.maxfilesizemb", 100)
-  // Database
+	// Database
 	viper.SetDefault("db.host", "localhost")
 	viper.SetDefault("db.port", 5432)
 	viper.SetDefault("db.user", "scanfile")
 	viper.SetDefault("db.database", "scanfile")
 	viper.SetDefault("db.password", "CHANGEME")
 	viper.SetDefault("db.debug", false)
-  // Others
-  viper.SetDefault("processing.oleurl", "http://localhost:5000")
+	// Others
+	viper.SetDefault("processing.oleurl", "http://localhost:5000")
 	viper.SetDefault("store.path", "./storage/files/")
-  viper.SetDefault("debug", false)
+	viper.SetDefault("debug", false)
 }
 
 func SaveConfig() error {
diff --git a/server/internal/database/createFile.go b/server/internal/database/createFile.go
index 516fa1f..cca36bd 100644
--- a/server/internal/database/createFile.go
+++ b/server/internal/database/createFile.go
@@ -2,8 +2,8 @@ package database
 
 import (
 	"context"
+	"encoding/hex"
 	"log/slog"
-  "encoding/hex"
 
 	"github.com/jackc/pgx/v5"
 	"golang.org/x/crypto/blake2b"
@@ -21,29 +21,29 @@ func CreateFile(ctx context.Context, name string, fileBytes []byte) (sqlc.File,
 	var err error
 
 	bl2hash := blake2b.Sum256(fileBytes)
-  slog.Debug("calculated Blake2b hash", "file-name", name, "file-bl2", hex.EncodeToString(bl2hash[:]), "file-size", len(fileBytes))
-  mime, _ := store.GetBytesFileType(fileBytes[:262])
+	slog.Debug("calculated Blake2b hash", "file-name", name, "file-bl2", hex.EncodeToString(bl2hash[:]), "file-size", len(fileBytes))
+	mime, _ := store.GetBytesFileType(fileBytes[:262])
 
 	file, err = queries.CreateFile(ctx, sqlc.CreateFileParams{
-    Name: name,
-    Mimetype: mime,
-    Size: int64(len(fileBytes)),
-    Blake2: bl2hash[:],
-  })
+		Name:     name,
+		Mimetype: mime,
+		Size:     int64(len(fileBytes)),
+		Blake2:   bl2hash[:],
+	})
 	if err == pgx.ErrNoRows {
-    file, err := queries.GetFileByBlake2(ctx, bl2hash[:])
-    if err != nil {
-		  slog.Error("Error saving file to database", "error", err, "file-name", name)
-      return file, err
-    }
-	  slog.Debug("File already exists", "file-uuid", file.ID.String(), "file-name", file.Name, "file-bl2", hex.EncodeToString(file.Blake2), "file-size", file.Size, "file-mime", file.Mimetype, "file-description", file.Description.String)
+		file, err := queries.GetFileByBlake2(ctx, bl2hash[:])
+		if err != nil {
+			slog.Error("Error saving file to database", "error", err, "file-name", name)
+			return file, err
+		}
+		slog.Debug("File already exists", "file-uuid", file.ID.String(), "file-name", file.Name, "file-bl2", hex.EncodeToString(file.Blake2), "file-size", file.Size, "file-mime", file.Mimetype, "file-description", file.Description.String)
 		return file, nil
 	}
 	if err != nil {
 		slog.Error("Error saving file to database", "error", err, "file-name", name)
 		err = nil
 	} else {
-	  slog.Debug("New file created", "file-uuid", file.ID.String(), "file-name", file.Name, "file-bl2", hex.EncodeToString(file.Blake2), "file-size", file.Size, "file-mime", file.Mimetype, "file-description", file.Description.String)
+		slog.Debug("New file created", "file-uuid", file.ID.String(), "file-name", file.Name, "file-bl2", hex.EncodeToString(file.Blake2), "file-size", file.Size, "file-mime", file.Mimetype, "file-description", file.Description.String)
 	}
 
 	//Using UUIDs instead of the file hash to make switching storage backends easier
diff --git a/server/internal/database/file.go b/server/internal/database/file.go
index 453dc09..4646dbf 100644
--- a/server/internal/database/file.go
+++ b/server/internal/database/file.go
@@ -24,10 +24,10 @@ func GetFileByID(fileID string) (sqlc.File, error) {
 
 func InsertFileProperties(properties sqlc.InsertFilePropertiesParams) error {
 	query := sqlc.New(pool)
-  slog.Debug("InsertFileProperties", "file-uuid", properties.ID.String(), "file-sha256", 
-    hex.EncodeToString(properties.Sha256), "file-md5", hex.EncodeToString(properties.Md5), 
-    "file-mime", properties.LibmagicMime.String, "file-extension", properties.LibmagicExtension.String, 
-    "file-apple", properties.LibmagicApple.String)
+	slog.Debug("InsertFileProperties", "file-uuid", properties.ID.String(), "file-sha256",
+		hex.EncodeToString(properties.Sha256), "file-md5", hex.EncodeToString(properties.Md5),
+		"file-mime", properties.LibmagicMime.String, "file-extension", properties.LibmagicExtension.String,
+		"file-apple", properties.LibmagicApple.String)
 	err := query.InsertFileProperties(context.Background(), properties)
 	if err != nil {
 		slog.Error("Unable to add file properties", "file-uuid", properties.ID.String(), "error", err)
@@ -49,24 +49,24 @@ func InsertJsonResult(fileID pgtype.UUID, data []byte, table string) error {
 		err = query.InsertFileMsofficeOlevba(context.Background(), sqlc.InsertFileMsofficeOlevbaParams{FileID: fileID, Data: data})
 	case "msoffice_mraptor":
 		err = query.InsertFileMsofficeMraptor(context.Background(), sqlc.InsertFileMsofficeMraptorParams{FileID: fileID, Data: data})
-  default:
-    err = fmt.Errorf("Invalid table name")
+	default:
+		err = fmt.Errorf("Invalid table name")
 	}
 	if err != nil {
 		slog.Error("Unable to insert DIEC results", "file-uuid", fileID.String(), "error", err)
-    return err
+		return err
 	}
-  slog.Debug("InsertJsonResult", "file-uuid", fileID.String(), "table", table)
+	slog.Debug("InsertJsonResult", "file-uuid", fileID.String(), "table", table)
 	return nil
 }
 
 // GetFileMime() returns the MimeType for a file
 func GetFileMime(fileID pgtype.UUID) (string, error) {
-  query := sqlc.New(pool)
-  mimeType, err := query.GetFileMime(context.Background(), fileID)
-  if err != nil {
-    slog.Error("Error getting file Mimetype", "file-uuid", fileID.String(), "error", err)
-    return "", err
-  }
-  return mimeType, nil
+	query := sqlc.New(pool)
+	mimeType, err := query.GetFileMime(context.Background(), fileID)
+	if err != nil {
+		slog.Error("Error getting file Mimetype", "file-uuid", fileID.String(), "error", err)
+		return "", err
+	}
+	return mimeType, nil
 }
diff --git a/server/internal/processing/basic/basic.go b/server/internal/processing/basic/basic.go
index d4ca34e..a943b20 100644
--- a/server/internal/processing/basic/basic.go
+++ b/server/internal/processing/basic/basic.go
@@ -12,7 +12,7 @@ import (
 
 // BasicProcessing() determines type agnostic information about the file
 func BasicProcessing(job sqlc.ProcessingJob) error {
-  database.StartProcessingJob(job.ID)
+	database.StartProcessingJob(job.ID)
 	fileBytes, err := store.GetFileBytes(job.FileID.String())
 	if err != nil {
 		database.FailProcessingJob(job.ID, err)
diff --git a/server/internal/processing/basic/diec.go b/server/internal/processing/basic/diec.go
index 5096062..86e0bd2 100644
--- a/server/internal/processing/basic/diec.go
+++ b/server/internal/processing/basic/diec.go
@@ -24,8 +24,8 @@ func DiecScan(fileName string) ([]byte, error) {
 		return by, err
 	}
 
-  if json.Valid(result) == false {
-    return by, fmt.Errorf("JSON not valid")
-  }
+	if json.Valid(result) == false {
+		return by, fmt.Errorf("JSON not valid")
+	}
 	return result, nil
 }
diff --git a/server/internal/processing/msoffice/mraptor.go b/server/internal/processing/msoffice/mraptor.go
index bbb51a8..023676a 100644
--- a/server/internal/processing/msoffice/mraptor.go
+++ b/server/internal/processing/msoffice/mraptor.go
@@ -12,31 +12,30 @@ import (
 	"github.com/spf13/viper"
 )
 
-
 // MraptorScan() requests a scan of the file from the ole service
 func MraptorScan(fileID pgtype.UUID) error {
-  slog.Debug("Starting MacroRaptor scan", "file-uuid", fileID.String())
-  oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
-  if err != nil {
-    slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
-  }
-  oleidUrl.Path = "/olevba/analyze"
-  oleidUrl.Query().Add("file", fileID.String())
-  oleidResp, err := http.Get(oleidUrl.String())
-  slog.Debug("MraptorScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
-  if err != nil {
-    slog.Error("Error getting mraptor info from service", "file-uuid", fileID.String(), "error", err)
-  }
-  var body []byte
-  _, err = oleidResp.Body.Read(body)
-  if err != nil {
-    slog.Error("Error parsing mraptor body", "file-uuid", fileID.String(), "error", err)
-  }
+	slog.Debug("Starting MacroRaptor scan", "file-uuid", fileID.String())
+	oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
+	if err != nil {
+		slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
+	}
+	oleidUrl.Path = "/olevba/analyze"
+	oleidUrl.Query().Add("file", fileID.String())
+	oleidResp, err := http.Get(oleidUrl.String())
+	slog.Debug("MraptorScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
+	if err != nil {
+		slog.Error("Error getting mraptor info from service", "file-uuid", fileID.String(), "error", err)
+	}
+	var body []byte
+	_, err = oleidResp.Body.Read(body)
+	if err != nil {
+		slog.Error("Error parsing mraptor body", "file-uuid", fileID.String(), "error", err)
+	}
 
-  if json.Valid(body) == false {
-    return fmt.Errorf("JSON not valid")
-  }
-  slog.Debug("MraptorScan", "file-uuid", fileID.String(), "data", body)
-  database.InsertJsonResult(fileID, body, "msoffice_mraptor")
-  return nil
+	if json.Valid(body) == false {
+		return fmt.Errorf("JSON not valid")
+	}
+	slog.Debug("MraptorScan", "file-uuid", fileID.String(), "data", body)
+	database.InsertJsonResult(fileID, body, "msoffice_mraptor")
+	return nil
 }
diff --git a/server/internal/processing/msoffice/msoffice.go b/server/internal/processing/msoffice/msoffice.go
index 143708c..58718ec 100644
--- a/server/internal/processing/msoffice/msoffice.go
+++ b/server/internal/processing/msoffice/msoffice.go
@@ -5,23 +5,22 @@ import (
 	"git.jmbit.de/jmb/scanfile/server/internal/sqlc"
 )
 
-
 func MSOfficeProcessing(job sqlc.ProcessingJob) error {
-  database.StartProcessingJob(job.ID)
-  err := OleIDScan(job.FileID)
-  if err != nil {
-    database.FailProcessingJob(job.ID, err)
-    return err
-  }
-  err = OleVBAScan(job.FileID)
-  if err != nil {
-    database.FailProcessingJob(job.ID, err)
-    return err
-  }
-  err = MraptorScan(job.FileID)
-  if err != nil {
-    database.FailProcessingJob(job.ID, err)
-    return err
-  }
-  return nil
+	database.StartProcessingJob(job.ID)
+	err := OleIDScan(job.FileID)
+	if err != nil {
+		database.FailProcessingJob(job.ID, err)
+		return err
+	}
+	err = OleVBAScan(job.FileID)
+	if err != nil {
+		database.FailProcessingJob(job.ID, err)
+		return err
+	}
+	err = MraptorScan(job.FileID)
+	if err != nil {
+		database.FailProcessingJob(job.ID, err)
+		return err
+	}
+	return nil
 }
diff --git a/server/internal/processing/msoffice/oleid.go b/server/internal/processing/msoffice/oleid.go
index aa3dbbe..98f6f32 100644
--- a/server/internal/processing/msoffice/oleid.go
+++ b/server/internal/processing/msoffice/oleid.go
@@ -12,31 +12,30 @@ import (
 	"github.com/spf13/viper"
 )
 
-
 func OleIDScan(fileID pgtype.UUID) error {
 
-  slog.Debug("Starting OleID scan", "file-uuid", fileID.String())
-  oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
-  if err != nil {
-    slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
-  }
-  oleidUrl.Path = "/oleid/analyze"
-  oleidUrl.Query().Add("file", fileID.String())
-  oleidResp, err := http.Get(oleidUrl.String())
-  slog.Debug("OleIDScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
-  if err != nil {
-    slog.Error("Error getting oleid info from service", "file-uuid", fileID.String(), "error", err)
-  }
-  var body []byte
-  _, err = oleidResp.Body.Read(body)
-  if err != nil {
-    slog.Error("Error parsing oleid body", "file-uuid", fileID.String(), "error", err)
-  }
+	slog.Debug("Starting OleID scan", "file-uuid", fileID.String())
+	oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
+	if err != nil {
+		slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
+	}
+	oleidUrl.Path = "/oleid/analyze"
+	oleidUrl.Query().Add("file", fileID.String())
+	oleidResp, err := http.Get(oleidUrl.String())
+	slog.Debug("OleIDScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
+	if err != nil {
+		slog.Error("Error getting oleid info from service", "file-uuid", fileID.String(), "error", err)
+	}
+	var body []byte
+	_, err = oleidResp.Body.Read(body)
+	if err != nil {
+		slog.Error("Error parsing oleid body", "file-uuid", fileID.String(), "error", err)
+	}
 
-  if json.Valid(body) == false {
-    return fmt.Errorf("JSON not valid")
-  }
-  slog.Debug("OleIDScan", "file-uuid", fileID.String(), "data", body)
-  database.InsertJsonResult(fileID, body, "msoffice_oleid")
-  return nil
+	if json.Valid(body) == false {
+		return fmt.Errorf("JSON not valid")
+	}
+	slog.Debug("OleIDScan", "file-uuid", fileID.String(), "data", body)
+	database.InsertJsonResult(fileID, body, "msoffice_oleid")
+	return nil
 }
diff --git a/server/internal/processing/msoffice/olevba.go b/server/internal/processing/msoffice/olevba.go
index 5c00c05..052bed8 100644
--- a/server/internal/processing/msoffice/olevba.go
+++ b/server/internal/processing/msoffice/olevba.go
@@ -12,30 +12,29 @@ import (
 	"github.com/spf13/viper"
 )
 
-
 func OleVBAScan(fileID pgtype.UUID) error {
-  slog.Debug("Starting OLEvba scan", "file-uuid", fileID.String())
-  oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
-  if err != nil {
-    slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
-  }
-  oleidUrl.Path = "/olevba/analyze"
-  oleidUrl.Query().Add("file", fileID.String())
-  oleidResp, err := http.Get(oleidUrl.String())
-  slog.Debug("OleVBAScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
-  if err != nil {
-    slog.Error("Error getting olevba info from service", "file-uuid", fileID.String(), "error", err)
-  }
-  var body []byte
-  _, err = oleidResp.Body.Read(body)
-  if err != nil {
-    slog.Error("Error parsing olevba body", "file-uuid", fileID.String(), "error", err)
-  }
+	slog.Debug("Starting OLEvba scan", "file-uuid", fileID.String())
+	oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
+	if err != nil {
+		slog.Error("Error parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
+	}
+	oleidUrl.Path = "/olevba/analyze"
+	oleidUrl.Query().Add("file", fileID.String())
+	oleidResp, err := http.Get(oleidUrl.String())
+	slog.Debug("OleVBAScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
+	if err != nil {
+		slog.Error("Error getting olevba info from service", "file-uuid", fileID.String(), "error", err)
+	}
+	var body []byte
+	_, err = oleidResp.Body.Read(body)
+	if err != nil {
+		slog.Error("Error parsing olevba body", "file-uuid", fileID.String(), "error", err)
+	}
 
-  if json.Valid(body) == false {
-    return fmt.Errorf("JSON not valid")
-  }
-  slog.Debug("OleVBAScan", "file-uuid", fileID.String(), "data", body)
-  database.InsertJsonResult(fileID, body, "msoffice_olevba")
-  return nil
+	if json.Valid(body) == false {
+		return fmt.Errorf("JSON not valid")
+	}
+	slog.Debug("OleVBAScan", "file-uuid", fileID.String(), "data", body)
+	database.InsertJsonResult(fileID, body, "msoffice_olevba")
+	return nil
 }
diff --git a/server/internal/processing/processing.go b/server/internal/processing/processing.go
index 5a0a81d..2e7b53f 100644
--- a/server/internal/processing/processing.go
+++ b/server/internal/processing/processing.go
@@ -21,28 +21,27 @@ func Setup(wg *sync.WaitGroup) {
 
 // Submit() starts the analysis process for a file.
 func Submit(ctx context.Context, file pgtype.UUID) error {
-  // Always start a basic task
+	// Always start a basic task
 	job, err := database.NewProcessingJob(ctx, file, TypeBasic)
 	if err != nil {
 		slog.Error("Could not submit processing job", "error", err, "file-uuid", file, "type", TypeBasic)
 		return err
 	}
 
-  go basic.BasicProcessing(job)  
-  mimeType, err := database.GetFileMime(file)
+	go basic.BasicProcessing(job)
+	mimeType, err := database.GetFileMime(file)
 	if err != nil {
 		slog.Error("Could not retrieve MimeType", "error", err, "file-uuid", file)
 		return err
 	}
-  switch TypeFromMime(mimeType) {
-  case TypeMSOffice:
- 	  officeJob, err := database.NewProcessingJob(ctx, file, TypeMSOffice)
-	  if err != nil {
-	  	slog.Error("Could not submit processing job", "error", err, "file-uuid", file, "type", TypeMSOffice)
-	  	return err
-	  } 
-    go msoffice.MSOfficeProcessing(officeJob)  
-  }
+	switch TypeFromMime(mimeType) {
+	case TypeMSOffice:
+		officeJob, err := database.NewProcessingJob(ctx, file, TypeMSOffice)
+		if err != nil {
+			slog.Error("Could not submit processing job", "error", err, "file-uuid", file, "type", TypeMSOffice)
+			return err
+		}
+		go msoffice.MSOfficeProcessing(officeJob)
+	}
 	return nil
 }
-
diff --git a/server/internal/processing/types.go b/server/internal/processing/types.go
index 0de648d..ece6126 100644
--- a/server/internal/processing/types.go
+++ b/server/internal/processing/types.go
@@ -78,4 +78,3 @@ func TypeFromMime(mimetype string) string {
 
 	return TypeOther
 }
-
diff --git a/server/internal/server/routes.go b/server/internal/server/routes.go
index 841075b..09dfbf4 100644
--- a/server/internal/server/routes.go
+++ b/server/internal/server/routes.go
@@ -9,16 +9,15 @@ import (
 
 func RegisterRoutes() *http.ServeMux {
 	mux := http.NewServeMux()
-  // Web interface
+	// Web interface
 	mux.HandleFunc("/", web.IndexWebHandler)
 	mux.HandleFunc("/about", web.AboutWebHandler)
 	mux.HandleFunc("/files/{uuid}", web.FileViewWebHandler)
 	mux.HandleFunc("POST /upload", web.IndexUploadHandler)
 	mux.Handle("/assets/", http.FileServer(http.FS(web.Files)))
 
-
-  // REST API
-  mux.HandleFunc("/api/v0/submit", api.SubmitRestHandler)
+	// REST API
+	mux.HandleFunc("/api/v0/submit", api.SubmitRestHandler)
 
 	return mux
 }
diff --git a/server/internal/store/filetype.go b/server/internal/store/filetype.go
index 382584a..5129659 100644
--- a/server/internal/store/filetype.go
+++ b/server/internal/store/filetype.go
@@ -21,14 +21,14 @@ func GetFileType(fileId string) (string, error) {
 	// We only have to pass the file header = first 261 bytes
 	head := make([]byte, 261)
 	file.Read(head)
-  return GetBytesFileType(head)
+	return GetBytesFileType(head)
 }
 
 // Returns the MimeType for a []byte
 // We only have to pass the file header = first 261 bytes
 func GetBytesFileType(data []byte) (string, error) {
 	kind, err := filetype.Match(data)
-  slog.Debug("GetBytesFileType", "data", data, "file-mime", kind.MIME.Value)
+	slog.Debug("GetBytesFileType", "data", data, "file-mime", kind.MIME.Value)
 	if err != nil {
 		slog.Error("Could not determine file type", "error", err)
 		return "application/octet-stream", err
diff --git a/server/internal/utils/jsonError.go b/server/internal/utils/jsonError.go
index 6e5fe5b..288b2e4 100644
--- a/server/internal/utils/jsonError.go
+++ b/server/internal/utils/jsonError.go
@@ -7,20 +7,18 @@ import (
 )
 
 type ErrorResponse struct {
-  Message string `json:"message"`
-  Code int `json:"code,omitempty"`
+	Message string `json:"message"`
+	Code    int    `json:"code,omitempty"`
 }
 
-
-
 func WriteJSONError(w http.ResponseWriter, message string, statusCode int) {
-  w.Header().Set("Content-Type", "application/json")
-  w.WriteHeader(statusCode)
-  errorRes := ErrorResponse{Message: message, Code: statusCode}
-  enc := json.NewEncoder(w)
-  enc.SetIndent("", "  ")
-  err := enc.Encode(errorRes) // Encode and write the JSON response
-  if err != nil {
-    slog.Error("Error in WriteJSONError", "error", err)
-  }
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	errorRes := ErrorResponse{Message: message, Code: statusCode}
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	err := enc.Encode(errorRes) // Encode and write the JSON response
+	if err != nil {
+		slog.Error("Error in WriteJSONError", "error", err)
+	}
 }
diff --git a/server/main.go b/server/main.go
index 8bc3bee..72d4d82 100644
--- a/server/main.go
+++ b/server/main.go
@@ -34,10 +34,10 @@ func main() {
 	log.SetOutput(os.Stderr)
 	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, nil)))
 	config.ReadConfigFile("")
-  if viper.GetBool("debug") {
-	  slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})))
-    slog.Debug("Debug logging enabled")
-  }
+	if viper.GetBool("debug") {
+		slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})))
+		slog.Debug("Debug logging enabled")
+	}
 	var wg sync.WaitGroup
 	database.Connect()
 	database.Ping()
diff --git a/server/web/index.go b/server/web/index.go
index 83c6f93..7fbe8b6 100644
--- a/server/web/index.go
+++ b/server/web/index.go
@@ -31,14 +31,14 @@ func IndexUploadHandler(w http.ResponseWriter, r *http.Request) {
 	r.Body = http.MaxBytesReader(w, r.Body, maxUploadSize)
 	defer r.Body.Close()
 	fileData, fileHeader, err := r.FormFile("file")
-  slog.Debug("File form submitted", "file-name", fileHeader.Filename, "file-size", fileHeader.Size)
+	slog.Debug("File form submitted", "file-name", fileHeader.Filename, "file-size", fileHeader.Size)
 	if err != nil {
 		slog.Error("Error parsing form in IndexUploadHandler", "error", err)
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	fileBytes, err := io.ReadAll(fileData)
-  slog.Debug("File from form read", "file-name", fileHeader.Filename, "file-size", len(fileBytes))
+	slog.Debug("File from form read", "file-name", fileHeader.Filename, "file-size", len(fileBytes))
 	if err != nil {
 		slog.Error("Error reading file in IndexUploadHandler", "error", err)
 		http.Error(w, err.Error(), http.StatusBadRequest)
@@ -51,7 +51,7 @@ func IndexUploadHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-  err = processing.Submit(r.Context(), file.ID)
+	err = processing.Submit(r.Context(), file.ID)
 	if err != nil {
 		slog.Error("Error submitting file for processing in IndexUploadHandler", "error", err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
diff --git a/tmp/build-errors.log b/tmp/build-errors.log
index 0c95a68..627a172 100644
--- a/tmp/build-errors.log
+++ b/tmp/build-errors.log
@@ -1 +1 @@
-exit status 2exit status 2exit status 2exit status 2exit status 2exit status 2exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1
\ No newline at end of file
+exit status 2exit status 2exit status 2exit status 2exit status 2exit status 2exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1
\ No newline at end of file