diff --git a/services/data-manager/service/db/dbGroups.go b/services/data-manager/service/db/dbGroups.go
index f4776c3..059fb65 100644
--- a/services/data-manager/service/db/dbGroups.go
+++ b/services/data-manager/service/db/dbGroups.go
@@ -20,60 +20,46 @@ import (
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/models"
-	"htwkalender/data-manager/model"
 	"log/slog"
 )
 
-func SaveGroups(seminarGroup []model.SeminarGroup, collection *models.Collection, app *pocketbase.PocketBase) ([]*models.Record, error) {
-	var savedRecords []*models.Record
-	var tobeSavedGroups []model.SeminarGroup
-	var insertRecords []*models.Record
-
-	for _, group := range seminarGroup {
-		dbGroup, err := FindGroupByCourseAndSemester(group.Course, group.Semester, app)
-
-		if dbGroup == nil && err.Error() == "sql: no rows in result set" {
-			tobeSavedGroups = append(tobeSavedGroups, group)
-		} else if err != nil {
-			return nil, err
-		}
-	}
-
-	// create record for each group that's not already in the database
-	for _, group := range tobeSavedGroups {
-		record := models.NewRecord(collection)
-		record.Set("university", group.University)
-		record.Set("shortcut", group.GroupShortcut)
-		record.Set("groupId", group.GroupId)
-		record.Set("course", group.Course)
-		record.Set("faculty", group.Faculty)
-		record.Set("facultyId", group.FacultyId)
-		record.Set("semester", group.Semester)
-		insertRecords = append(insertRecords, record)
-	}
-
-	// save all records
-	for _, record := range insertRecords {
-		if record != nil {
-			err := app.Dao().SaveRecord(record)
-			if err == nil {
-				savedRecords = append(savedRecords, record)
-			} else {
-				return nil, err
-			}
-		}
-	}
-
-	return savedRecords, nil
+type SeminarGroup struct {
+	University    string `db:"university" json:"university"`
+	GroupShortcut string `db:"shortcut" json:"shortcut"`
+	GroupId       string `db:"groupId" json:"groupId"`
+	Course        string `db:"course" json:"course"`
+	Faculty       string `db:"faculty" json:"faculty"`
+	FacultyId     string `db:"facultyId" json:"facultyId"`
+	Semester      string `db:"semester" json:"semester"`
+	models.BaseModel
 }
 
-func FindGroupByCourseAndSemester(course string, semester string, app *pocketbase.PocketBase) (*model.SeminarGroup, error) {
-	var group model.SeminarGroup
-	err := app.Dao().DB().Select("*").From("groups").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).One(&group)
+func (s *SeminarGroup) TableName() string {
+	return "groups"
+}
+
+type SeminarGroups []*SeminarGroup
+
+func SaveGroups(seminarGroups SeminarGroups, app *pocketbase.PocketBase) (SeminarGroups, error) {
+
+	// delete all groups from the database
+	execute, err := app.Dao().DB().Delete("groups", dbx.NewExp("1 = 1")).Execute()
 	if err != nil {
 		return nil, err
 	}
-	return &group, nil
+	rowCount, _ := execute.RowsAffected()
+
+	savedGroups := SeminarGroups{}
+	for _, group := range seminarGroups {
+		saveErr := app.Dao().Save(group)
+		if saveErr != nil {
+			return nil, saveErr
+		}
+		savedGroups = append(savedGroups, group)
+	}
+	slog.Info("Saved all groups to the database", "insert", len(savedGroups), "deleted", rowCount)
+
+	return savedGroups, nil
 }
 
 func GetAllCourses(app *pocketbase.PocketBase) []string {
diff --git a/services/data-manager/service/fetch/v1/fetchSeminarGroupService.go b/services/data-manager/service/fetch/v1/fetchSeminarGroupService.go
index 32cfff0..316ff57 100644
--- a/services/data-manager/service/fetch/v1/fetchSeminarGroupService.go
+++ b/services/data-manager/service/fetch/v1/fetchSeminarGroupService.go
@@ -20,7 +20,6 @@ import (
 	"encoding/xml"
 	"fmt"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/models"
 	"htwkalender/data-manager/model"
 	"htwkalender/data-manager/service/db"
 	"htwkalender/data-manager/service/functions"
@@ -58,8 +57,8 @@ func getSeminarHTML(semester string) (string, error) {
 
 }
 
-func FetchSeminarGroups(app *pocketbase.PocketBase) ([]*models.Record, error) {
-	var groups []model.SeminarGroup
+func FetchSeminarGroups(app *pocketbase.PocketBase) (db.SeminarGroups, error) {
+	var groups db.SeminarGroups
 
 	semesterString := functions.CalculateSemesterList(time.RealClock{})
 	var results [2]string
@@ -77,26 +76,23 @@ func FetchSeminarGroups(app *pocketbase.PocketBase) ([]*models.Record, error) {
 	// filter duplicates
 	groups = removeDuplicates(groups)
 
-	collection, dbError := db.FindCollection(app, "groups")
+	insertedGroups, dbError := db.SaveGroups(groups, app)
 	if dbError != nil {
-		slog.Error("Error while searching collection groups", "error", dbError)
-		return nil, err
-	}
-	var insertedGroups []*models.Record
-
-	insertedGroups, dbError = db.SaveGroups(groups, collection, app)
-	if dbError != nil {
-		slog.Error("Error while saving groups", "error", dbError)
+		slog.Error("FetchSeminarGroups", "error", dbError)
 		return nil, err
 	}
 
 	return insertedGroups, nil
 }
 
-func removeDuplicates(groups []model.SeminarGroup) []model.SeminarGroup {
-	var uniqueGroups []model.SeminarGroup
+func removeDuplicates(groups db.SeminarGroups) db.SeminarGroups {
+	uniqueGroups := make(db.SeminarGroups, 0, len(groups))
+	seen := make(map[string]struct{}) // Use an empty struct to minimize memory usage
+
 	for _, group := range groups {
-		if !contains(uniqueGroups, group) {
+		key := group.Course + group.Semester
+		if _, exists := seen[key]; !exists {
+			seen[key] = struct{}{}
 			uniqueGroups = append(uniqueGroups, group)
 		}
 	}
@@ -112,7 +108,7 @@ func contains(groups []model.SeminarGroup, group model.SeminarGroup) bool {
 	return false
 }
 
-func parseSeminarGroups(result string, semester string) []model.SeminarGroup {
+func parseSeminarGroups(result string, semester string) db.SeminarGroups {
 
 	var studium model.Studium
 	err := xml.Unmarshal([]byte(result), &studium)
@@ -120,11 +116,11 @@ func parseSeminarGroups(result string, semester string) []model.SeminarGroup {
 		return nil
 	}
 
-	var seminarGroups []model.SeminarGroup
+	var seminarGroups db.SeminarGroups
 	for _, faculty := range studium.Faculty {
 		for _, Studiengang := range faculty.Studiengang {
 			for _, Studienrichtung := range Studiengang.Semgrp {
-				seminarGroup := model.SeminarGroup{
+				seminarGroup := db.SeminarGroup{
 					University:    "HTWK-Leipzig",
 					GroupShortcut: Studiengang.Name,
 					GroupId:       Studiengang.ID,
@@ -133,7 +129,7 @@ func parseSeminarGroups(result string, semester string) []model.SeminarGroup {
 					FacultyId:     faculty.ID,
 					Semester:      semester,
 				}
-				seminarGroups = append(seminarGroups, seminarGroup)
+				seminarGroups = append(seminarGroups, &seminarGroup)
 			}
 		}
 	}