diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index c2f69b82..5eedf8e4 100755
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -24,16 +24,6 @@ export default defineConfig({
             // { text: 'Examples', link: '/markdown-examples' }
         ],
 
-        sidebar: [
-            {
-                text: "Algemeen",
-                items: [
-                    // { text: 'Markdown Examples', link: '/markdown-examples' },
-                    // { text: 'Runtime API Examples', link: '/api-examples' }
-                ],
-            },
-        ],
-
         socialLinks: [
             { icon: "github", link: "https://github.com/SELab-2/UGent-7" },
         ],
diff --git a/docs/en/index.md b/docs/en/index.md
index c22a4bae..fac2f489 100644
--- a/docs/en/index.md
+++ b/docs/en/index.md
@@ -4,8 +4,7 @@ layout: home
 
 hero:
   name: "Ypovoli"
-  text: "TODO"
-  tagline: TODO
+  text: Help pagina
   actions:
     - theme: brand
       text: Student
@@ -19,13 +18,5 @@ hero:
     - theme: brand
       text: Admin
       link: /en/admin-examples
-
-features:
-  - title: Feature A
-    details: lorem english
-  - title: Feature B
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
-  - title: Feature C
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
 ---
 
diff --git a/docs/en/student-examples.md b/docs/en/student-examples.md
index 838cc994..0e555eb3 100644
--- a/docs/en/student-examples.md
+++ b/docs/en/student-examples.md
@@ -93,9 +93,6 @@ This page describes how to interact with Ypovoli as a student.
   - Scroll to the "My Courses" section.
   - Click on the course of the desired project.
   - Under the "Current Projects" section, you will see all projects for this specific course.
-- Option 4:
-  - Click on "Projects" in the navigation bar.
-  - You will see an overview of all your projects.
 
 ::: info Project card explanation
 ![project card](../assets/en/project-card.png)
@@ -135,4 +132,4 @@ This page describes how to interact with Ypovoli as a student.
 
 ## View Previous Submissions Status
 - Go to the submission page.
-- It says there. !!! TODO !!!
+- It says there.
diff --git a/docs/nl/index.md b/docs/nl/index.md
index 9a981c2e..a73bf877 100644
--- a/docs/nl/index.md
+++ b/docs/nl/index.md
@@ -4,8 +4,7 @@ layout: home
 
 hero:
   name: "Ypovoli"
-  text: "TODO"
-  tagline: TODO
+  text: Help page
   actions:
     - theme: brand
       text: Student
@@ -19,13 +18,5 @@ hero:
     - theme: brand
       text: Admin
       link: /nl/admin-examples
-
-features:
-  - title: Feature A
-    details: lorem nederlands
-  - title: Feature B
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
-  - title: Feature C
-    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
 ---
 
diff --git a/docs/nl/student-examples.md b/docs/nl/student-examples.md
index 569e2179..4695c23c 100644
--- a/docs/nl/student-examples.md
+++ b/docs/nl/student-examples.md
@@ -93,9 +93,6 @@ Deze pagina beschrijft hoe u als student met Ypovoli interageert.
   - Scrol naar de sectie "Mijn vakken".
   - Druk hier op het vak van het gezochte project.
   - Onder de sectie "Lopende projecten" ziet u alle projecten voor dit specifieke vak.
-- Optie 4: 
-  - Druk in de navigatiebalk op "Projecten".
-  - U ziet een overzicht van al uw projecten.
 
 ::: info Project kaart uitleg
 <!-- TODO maybey ne fotoke en me numerkes aanduide -->
@@ -136,4 +133,4 @@ De kaart is als volgt ingedeeld:
 
 ## Status vorige indieningen bekijken
 - Ga naar indien pagina.
-- Staat daar bij. !!! TODO !!!
+- Staat daar bij.
diff --git a/frontend/src/composables/services/admin.service.ts b/frontend/src/composables/services/admin.service.ts
index b5e09ee7..5b576414 100644
--- a/frontend/src/composables/services/admin.service.ts
+++ b/frontend/src/composables/services/admin.service.ts
@@ -6,27 +6,27 @@ import { User } from '@/types/users/User.ts';
 interface AdminState {
     admins: Ref<User[] | null>;
     admin: Ref<User | null>;
-    getAdminByID: (id: string) => Promise<void>;
-    getAdmins: () => Promise<void>;
-    createAdmin: (adminData: User) => Promise<void>;
-    deleteAdmin: (id: string) => Promise<void>;
+    getAdminByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getAdmins: (selfProcessError?: boolean) => Promise<void>;
+    createAdmin: (adminData: User, selfProcessError?: boolean) => Promise<void>;
+    deleteAdmin: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useAdmin(): AdminState {
     const admins = ref<User[] | null>(null);
     const admin = ref<User | null>(null);
 
-    async function getAdminByID(id: string): Promise<void> {
+    async function getAdminByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.retrieve.replace('{id}', id);
-        await get<User>(endpoint, admin, User.fromJSON);
+        await get<User>(endpoint, admin, User.fromJSON, selfProcessError);
     }
 
-    async function getAdmins(): Promise<void> {
+    async function getAdmins(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.index;
-        await getList<User>(endpoint, admins, User.fromJSON);
+        await getList<User>(endpoint, admins, User.fromJSON, selfProcessError);
     }
 
-    async function createAdmin(user: User): Promise<void> {
+    async function createAdmin(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.index;
         await createToast<User>(
             'admin',
@@ -36,12 +36,14 @@ export function useAdmin(): AdminState {
             },
             admin,
             User.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteAdmin(id: string): Promise<void> {
+    async function deleteAdmin(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.retrieve.replace('{id}', id);
-        await deleteId<User>(endpoint, admin, User.fromJSON);
+        await deleteId<User>(endpoint, admin, User.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/assistant.service.ts b/frontend/src/composables/services/assistant.service.ts
index 98841db4..c2e5eff3 100644
--- a/frontend/src/composables/services/assistant.service.ts
+++ b/frontend/src/composables/services/assistant.service.ts
@@ -20,14 +20,14 @@ interface AssistantState {
     assistant: Ref<Assistant | null>;
     response: Ref<Response | null>;
     assistantPagination: Ref<PaginatorResponse<Assistant> | null>;
-    getAssistantByID: (id: string, init?: boolean) => Promise<void>;
-    getAssistantsByCourse: (courseId: string) => Promise<void>;
-    getAssistants: () => Promise<void>;
-    searchAssistants: (filters: Filter, page: number, pageSize: number) => Promise<void>;
-    assistantJoinCourse: (courseId: string, assistantId: string) => Promise<void>;
-    assistantLeaveCourse: (courseId: string, assistantId: string) => Promise<void>;
-    createAssistant: (assistantData: Assistant) => Promise<void>;
-    deleteAssistant: (id: string) => Promise<void>;
+    getAssistantByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getAssistantsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getAssistants: (selfProcessError?: boolean) => Promise<void>;
+    searchAssistants: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    assistantJoinCourse: (courseId: string, assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    assistantLeaveCourse: (courseId: string, assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    createAssistant: (assistantData: Assistant, selfProcessError?: boolean) => Promise<void>;
+    deleteAssistant: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useAssistant(): AssistantState {
@@ -37,37 +37,71 @@ export function useAssistant(): AssistantState {
     const response = ref<Response | null>(null);
     const assistantPagination = ref<PaginatorResponse<Assistant> | null>(null);
 
-    async function getAssistantByID(id: string): Promise<void> {
+    async function getAssistantByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.retrieve.replace('{id}', id);
-        await get<Assistant>(endpoint, assistant, Assistant.fromJSON);
+        await get<Assistant>(endpoint, assistant, Assistant.fromJSON, selfProcessError);
     }
 
-    async function getAssistantsByCourse(courseId: string): Promise<void> {
+    async function getAssistantsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
-        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON);
+        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfProcessError);
     }
 
-    async function getAssistants(): Promise<void> {
+    async function getAssistants(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.index;
-        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON);
+        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfProcessError);
     }
 
-    async function searchAssistants(filters: Filter, page: number, pageSize: number): Promise<void> {
+    async function searchAssistants(
+        filters: Filter,
+        page: number,
+        pageSize: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.assistants.search;
-        await getPaginatedList<Assistant>(endpoint, filters, page, pageSize, assistantPagination, Assistant.fromJSON);
+        await getPaginatedList<Assistant>(
+            endpoint,
+            filters,
+            page,
+            pageSize,
+            assistantPagination,
+            Assistant.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function assistantJoinCourse(courseId: string, assistantId: string): Promise<void> {
+    async function assistantJoinCourse(
+        courseId: string,
+        assistantId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
-        await create<Response>(endpoint, { assistant: assistantId }, response, Response.fromJSON);
+        await create<Response>(
+            endpoint,
+            { assistant: assistantId },
+            response,
+            Response.fromJSON,
+            undefined,
+            selfProcessError,
+        );
     }
 
-    async function assistantLeaveCourse(courseId: string, assistantId: string): Promise<void> {
+    async function assistantLeaveCourse(
+        courseId: string,
+        assistantId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
-        await deleteIdWithData<Response>(endpoint, { assistant: assistantId }, response, Response.fromJSON);
+        await deleteIdWithData<Response>(
+            endpoint,
+            { assistant: assistantId },
+            response,
+            Response.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function createAssistant(user: User): Promise<void> {
+    async function createAssistant(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.index;
         await createToast<Assistant>(
             'assistant',
@@ -77,12 +111,14 @@ export function useAssistant(): AssistantState {
             },
             assistant,
             Assistant.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteAssistant(id: string): Promise<void> {
+    async function deleteAssistant(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.retrieve.replace('{id}', id);
-        await deleteId<Assistant>(endpoint, assistant, Assistant.fromJSON);
+        await deleteId<Assistant>(endpoint, assistant, Assistant.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/course.service.ts b/frontend/src/composables/services/course.service.ts
index f9dad3f5..a6aa061e 100644
--- a/frontend/src/composables/services/course.service.ts
+++ b/frontend/src/composables/services/course.service.ts
@@ -1,30 +1,34 @@
 import { Course } from '@/types/Course.ts';
 import { type Ref, ref } from 'vue';
 import { endpoints } from '@/config/endpoints.ts';
-import { i18n } from '@/config/i18n.ts';
 import { get, getList, create, patch, deleteId, getPaginatedList } from '@/composables/services/helpers.ts';
 import { type Response } from '@/types/Response.ts';
 import { type CoursePaginatorResponse } from '@/types/filter/Paginator.ts';
 import { type Filter } from '@/types/filter/Filter.ts';
 import { type User } from '@/types/users/User.ts';
-import { useMessagesStore } from '@/store/messages.store.ts';
 
 interface CoursesState {
     pagination: Ref<CoursePaginatorResponse | null>;
     courses: Ref<Course[] | null>;
     course: Ref<Course | null>;
-    getCourseByID: (id: string) => Promise<void>;
-    getCourses: () => Promise<void>;
-    searchCourses: (filters: Filter, page: number, pageSize: number) => Promise<void>;
-    getCoursesByStudent: (studentId: string) => Promise<void>;
-    getCoursesByTeacher: (teacherId: string) => Promise<void>;
-    getCourseByAssistant: (assistantId: string) => Promise<void>;
-    getCoursesByUser: (user: User) => Promise<void>;
-    createCourse: (courseData: Course) => Promise<void>;
-    updateCourse: (courseData: Course) => Promise<void>;
-    cloneCourse: (courseId: string, cloneAssistants: boolean, cloneTeachers: boolean) => Promise<void>;
-    activateInvitationLink: (courseId: string, linkDuration: number) => Promise<void>;
-    deleteCourse: (id: string) => Promise<void>;
+
+    getCourseByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getCourses: (selfProcessError?: boolean) => Promise<void>;
+    searchCourses: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByTeacher: (teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    getCourseByAssistant: (assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByUser: (user: User, selfProcessError?: boolean) => Promise<void>;
+    createCourse: (courseData: Course, selfProcessError?: boolean) => Promise<void>;
+    updateCourse: (courseData: Course, selfProcessError?: boolean) => Promise<void>;
+    cloneCourse: (
+        courseId: string,
+        cloneAssistants: boolean,
+        cloneTeachers: boolean,
+        selfProcessError?: boolean,
+    ) => Promise<void>;
+    activateInvitationLink: (courseId: string, linkDuration: number, selfProcessError?: boolean) => Promise<void>;
+    deleteCourse: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useCourses(): CoursesState {
@@ -33,52 +37,62 @@ export function useCourses(): CoursesState {
     const course = ref<Course | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getCourseByID(id: string): Promise<void> {
+    async function getCourseByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.retrieve.replace('{id}', id);
-        await get<Course>(endpoint, course, Course.fromJSON);
+        await get<Course>(endpoint, course, Course.fromJSON, selfProcessError);
     }
 
-    async function getCourses(): Promise<void> {
+    async function getCourses(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.index;
-        await getList<Course>(endpoint, courses, Course.fromJSON);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function searchCourses(filters: Filter, page: number, pageSize: number): Promise<void> {
+    async function searchCourses(
+        filters: Filter,
+        page: number,
+        pageSize: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.courses.search;
-        await getPaginatedList<Course>(endpoint, filters, page, pageSize, pagination, Course.fromJSON);
+        await getPaginatedList<Course>(
+            endpoint,
+            filters,
+            page,
+            pageSize,
+            pagination,
+            Course.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function getCoursesByStudent(studentId: string): Promise<void> {
+    async function getCoursesByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byStudent.replace('{studentId}', studentId);
-        await getList<Course>(endpoint, courses, Course.fromJSON);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCoursesByTeacher(teacherId: string): Promise<void> {
+    async function getCoursesByTeacher(teacherId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byTeacher.replace('{teacherId}', teacherId);
-        await getList<Course>(endpoint, courses, Course.fromJSON);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCourseByAssistant(assistantId: string): Promise<void> {
+    async function getCourseByAssistant(assistantId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byAssistant.replace('{assistantId}', assistantId);
-        await getList<Course>(endpoint, courses, Course.fromJSON);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCoursesByUser(user: User): Promise<void> {
+    async function getCoursesByUser(user: User, selfProcessError: boolean = true): Promise<void> {
         if (user.isTeacher()) {
-            await getCoursesByTeacher(user.id);
+            await getCoursesByTeacher(user.id, selfProcessError);
         } else if (user.isAssistant()) {
-            await getCourseByAssistant(user.id);
+            await getCourseByAssistant(user.id, selfProcessError);
         } else if (user.isStudent()) {
-            await getCoursesByStudent(user.id);
+            await getCoursesByStudent(user.id, selfProcessError);
         } else {
             courses.value = [];
         }
     }
 
-    async function createCourse(courseData: Course): Promise<void> {
-        const { t } = i18n.global;
-        const { addSuccessMessage } = useMessagesStore();
-
+    async function createCourse(courseData: Course, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.index;
         await create<Course>(
             endpoint,
@@ -93,14 +107,12 @@ export function useCourses(): CoursesState {
             },
             course,
             Course.fromJSON,
-        );
-        addSuccessMessage(
-            t('toasts.messages.success'),
-            t('toasts.messages.courses.create.success', [course.value?.name]),
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function updateCourse(courseData: Course): Promise<void> {
+    async function updateCourse(courseData: Course, selfProcessError: boolean = true): Promise<void> {
         // Endpoint to update is same as retrieve
         const endpoint = endpoints.courses.retrieve.replace('{id}', courseData.id);
 
@@ -115,10 +127,17 @@ export function useCourses(): CoursesState {
                 private_course: courseData.private_course,
             },
             response,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function cloneCourse(courseId: string, cloneAssistants: boolean, cloneTeachers: boolean): Promise<void> {
+    async function cloneCourse(
+        courseId: string,
+        cloneAssistants: boolean,
+        cloneTeachers: boolean,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.courses.clone.replace('{courseId}', courseId);
         await create<Course>(
             endpoint,
@@ -128,15 +147,21 @@ export function useCourses(): CoursesState {
             },
             course,
             Course.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteCourse(id: string): Promise<void> {
+    async function deleteCourse(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.retrieve.replace('{id}', id);
-        await deleteId<Course>(endpoint, course, Course.fromJSON);
+        await deleteId<Course>(endpoint, course, Course.fromJSON, selfProcessError);
     }
 
-    async function activateInvitationLink(courseId: string, linkDuration: number): Promise<void> {
+    async function activateInvitationLink(
+        courseId: string,
+        linkDuration: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.courses.invitationLink.replace('{courseId}', courseId);
         await patch(
             endpoint,
@@ -144,6 +169,8 @@ export function useCourses(): CoursesState {
                 link_duration: linkDuration,
             },
             response,
+            undefined,
+            selfProcessError,
         );
     }
 
diff --git a/frontend/src/composables/services/docker.service.ts b/frontend/src/composables/services/docker.service.ts
index ba6f5d96..6ed450f2 100644
--- a/frontend/src/composables/services/docker.service.ts
+++ b/frontend/src/composables/services/docker.service.ts
@@ -17,12 +17,12 @@ interface DockerImagesState {
     pagination: Ref<PaginatorResponse<DockerImage> | null>;
     dockerImages: Ref<DockerImage[] | null>;
     response: Ref<Response | null>;
-    getDockerImages: () => Promise<void>;
-    searchDockerImages: (filters: Filter, page: number, pageSize: number) => Promise<void>;
-    patchDockerImage: (dockerData: DockerImage) => Promise<void>;
-    createDockerImage: (dockerData: DockerImage, file: File) => Promise<void>;
-    deleteDockerImage: (id: string) => Promise<void>;
-    deleteDockerImages: (ids: string[]) => Promise<void>;
+    getDockerImages: (selfProcessError?: boolean) => Promise<void>;
+    searchDockerImages: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    patchDockerImage: (dockerData: DockerImage, selfProcessError?: boolean) => Promise<void>;
+    createDockerImage: (dockerData: DockerImage, file: File, selfProcessError?: boolean) => Promise<void>;
+    deleteDockerImage: (id: string, selfProcessError?: boolean) => Promise<void>;
+    deleteDockerImages: (ids: string[], selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useDockerImages(): DockerImagesState {
@@ -30,22 +30,39 @@ export function useDockerImages(): DockerImagesState {
     const dockerImages = ref<DockerImage[] | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getDockerImages(): Promise<void> {
+    async function getDockerImages(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.index;
-        await getList<DockerImage>(endpoint, dockerImages, DockerImage.fromJSON);
+        await getList<DockerImage>(endpoint, dockerImages, DockerImage.fromJSON, selfProcessError);
     }
 
-    async function searchDockerImages(filters: Filter, page: number, pageSize: number): Promise<void> {
+    async function searchDockerImages(
+        filters: Filter,
+        page: number,
+        pageSize: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.dockerImages.search;
-        await getPaginatedList<DockerImage>(endpoint, filters, page, pageSize, pagination, DockerImage.fromJSON);
+        await getPaginatedList<DockerImage>(
+            endpoint,
+            filters,
+            page,
+            pageSize,
+            pagination,
+            DockerImage.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function patchDockerImage(dockerData: DockerImage): Promise<void> {
+    async function patchDockerImage(dockerData: DockerImage, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.patch.replace('{id}', dockerData.id);
-        await patch(endpoint, { public: dockerData.public }, response);
+        await patch(endpoint, { public: dockerData.public }, response, undefined, selfProcessError);
     }
 
-    async function createDockerImage(dockerData: DockerImage, file: File): Promise<void> {
+    async function createDockerImage(
+        dockerData: DockerImage,
+        file: File,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.dockerImages.index;
         await createToast<Response>(
             'docker',
@@ -58,18 +75,19 @@ export function useDockerImages(): DockerImagesState {
             response,
             Response.fromJSON,
             'multipart/form-data',
+            selfProcessError,
         );
     }
 
-    async function deleteDockerImage(id: string): Promise<void> {
+    async function deleteDockerImage(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.retrieve.replace('{id}', id);
-        await deleteId<Response>(endpoint, response, Response.fromJSON);
+        await deleteId<Response>(endpoint, response, Response.fromJSON, selfProcessError);
     }
 
-    async function deleteDockerImages(ids: string[]): Promise<void> {
+    async function deleteDockerImages(ids: string[], selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.deleteMany;
         const data = { ids };
-        await deleteIdWithData<Response>(endpoint, data, response, Response.fromJSON);
+        await deleteIdWithData<Response>(endpoint, data, response, Response.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/extra_checks.service.ts b/frontend/src/composables/services/extra_checks.service.ts
index 4f94fec7..1e7a99f1 100644
--- a/frontend/src/composables/services/extra_checks.service.ts
+++ b/frontend/src/composables/services/extra_checks.service.ts
@@ -7,10 +7,10 @@ import { Response } from '@/types/Response';
 interface ExtraCheckState {
     extraCheck: Ref<ExtraCheck | null>;
     extraChecks: Ref<ExtraCheck[] | null>;
-    getExtraChecksByProject: (projectId: string) => Promise<void>;
-    addExtraCheck: (extraCheckData: ExtraCheck, projectId: string) => Promise<void>;
-    setExtraChecks: (extraChecks: ExtraCheck[], projectId: string) => Promise<void>;
-    deleteExtraCheck: (extraCheckId: string) => Promise<void>;
+    getExtraChecksByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    addExtraCheck: (extraCheckData: ExtraCheck, projectId: string, selfProcessError?: boolean) => Promise<void>;
+    setExtraChecks: (extraChecks: ExtraCheck[], projectId: string, selfProcessError?: boolean) => Promise<void>;
+    deleteExtraCheck: (extraCheckId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useExtraCheck(): ExtraCheckState {
@@ -18,12 +18,16 @@ export function useExtraCheck(): ExtraCheckState {
     const extraChecks = ref<ExtraCheck[] | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getExtraChecksByProject(projectId: string): Promise<void> {
+    async function getExtraChecksByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.extraChecks.byProject.replace('{projectId}', projectId);
-        await getList<ExtraCheck>(endpoint, extraChecks, ExtraCheck.fromJSON);
+        await getList<ExtraCheck>(endpoint, extraChecks, ExtraCheck.fromJSON, selfProcessError);
     }
 
-    async function addExtraCheck(extraCheckData: ExtraCheck, projectId: string): Promise<void> {
+    async function addExtraCheck(
+        extraCheckData: ExtraCheck,
+        projectId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.extraChecks.byProject.replace('{projectId}', projectId);
         await create<ExtraCheck>(
             endpoint,
@@ -38,20 +42,25 @@ export function useExtraCheck(): ExtraCheckState {
             extraCheck,
             ExtraCheck.fromJSON,
             'multipart/form-data',
+            selfProcessError,
         );
     }
 
-    async function setExtraChecks(extraChecks: ExtraCheck[], projectId: string): Promise<void> {
+    async function setExtraChecks(
+        extraChecks: ExtraCheck[],
+        projectId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         for (const extraCheck of extraChecks) {
             if (extraCheck.id === '') {
-                await addExtraCheck(extraCheck, projectId);
+                await addExtraCheck(extraCheck, projectId, selfProcessError);
             }
         }
     }
 
-    async function deleteExtraCheck(extraCheckId: string): Promise<void> {
+    async function deleteExtraCheck(extraCheckId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.extraChecks.retrieve.replace('{id}', extraCheckId);
-        await deleteId(endpoint, response, Response.fromJSON);
+        await deleteId(endpoint, response, Response.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/faculty.service.ts b/frontend/src/composables/services/faculty.service.ts
index 8d9dfce4..6c2c31f4 100644
--- a/frontend/src/composables/services/faculty.service.ts
+++ b/frontend/src/composables/services/faculty.service.ts
@@ -6,27 +6,27 @@ import { get, getList, deleteId, createToast } from '@/composables/services/help
 interface FacultyState {
     faculties: Ref<Faculty[] | null>;
     faculty: Ref<Faculty | null>;
-    getFacultyByID: (id: string) => Promise<void>;
-    getFaculties: () => Promise<void>;
-    createFaculty: (facultyData: Faculty) => Promise<void>;
-    deleteFaculty: (id: string) => Promise<void>;
+    getFacultyByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getFaculties: (selfProcessError?: boolean) => Promise<void>;
+    createFaculty: (facultyData: Faculty, selfProcessError?: boolean) => Promise<void>;
+    deleteFaculty: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useFaculty(): FacultyState {
     const faculties = ref<Faculty[] | null>(null);
     const faculty = ref<Faculty | null>(null);
 
-    async function getFacultyByID(id: string): Promise<void> {
+    async function getFacultyByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.retrieve.replace('{id}', id);
-        await get<Faculty>(endpoint, faculty, Faculty.fromJSON);
+        await get<Faculty>(endpoint, faculty, Faculty.fromJSON, selfProcessError);
     }
 
-    async function getFaculties(): Promise<void> {
+    async function getFaculties(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.index;
-        await getList<Faculty>(endpoint, faculties, Faculty.fromJSON);
+        await getList<Faculty>(endpoint, faculties, Faculty.fromJSON, selfProcessError);
     }
 
-    async function createFaculty(facultyData: Faculty): Promise<void> {
+    async function createFaculty(facultyData: Faculty, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.index;
         await createToast<Faculty>(
             'faculty',
@@ -34,12 +34,14 @@ export function useFaculty(): FacultyState {
             { id: facultyData.id, name: facultyData.name },
             faculty,
             Faculty.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteFaculty(id: string): Promise<void> {
+    async function deleteFaculty(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.retrieve.replace('{id}', id);
-        await deleteId<Faculty>(endpoint, faculty, Faculty.fromJSON);
+        await deleteId<Faculty>(endpoint, faculty, Faculty.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/group.service.ts b/frontend/src/composables/services/group.service.ts
index 943118b7..cf212cff 100644
--- a/frontend/src/composables/services/group.service.ts
+++ b/frontend/src/composables/services/group.service.ts
@@ -7,13 +7,13 @@ import type { Response } from '@/types/Response.ts';
 interface GroupState {
     groups: Ref<Group[] | null>;
     group: Ref<Group | null>;
-    getGroupByID: (id: string) => Promise<void>;
-    getGroupsByProject: (projectId: string) => Promise<void>;
-    getGroupsByStudent: (studentId: string) => Promise<void>;
-    getGroupByStudentProject: (projectId: string) => Promise<void>;
-    createGroup: (groupData: Group, projectId: string) => Promise<void>;
-    updateGroup: (groupData: Partial<Group>) => Promise<void>;
-    deleteGroup: (id: string) => Promise<void>;
+    getGroupByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getGroupsByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    getGroupsByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    getGroupByStudentProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    createGroup: (groupData: Group, projectId: string, selfProcessError?: boolean) => Promise<void>;
+    updateGroup: (groupData: Partial<Group>, selfProcessError?: boolean) => Promise<void>;
+    deleteGroup: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useGroup(): GroupState {
@@ -21,27 +21,27 @@ export function useGroup(): GroupState {
     const group = ref<Group | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getGroupByID(id: string): Promise<void> {
+    async function getGroupByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.retrieve.replace('{id}', id);
-        await get<Group>(endpoint, group, Group.fromJSON);
+        await get<Group>(endpoint, group, Group.fromJSON, selfProcessError);
     }
 
-    async function getGroupsByProject(projectId: string): Promise<void> {
+    async function getGroupsByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byProject.replace('{projectId}', projectId);
-        await getList<Group>(endpoint, groups, Group.fromJSON);
+        await getList<Group>(endpoint, groups, Group.fromJSON, selfProcessError);
     }
 
-    async function getGroupsByStudent(studentId: string): Promise<void> {
+    async function getGroupsByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byStudent.replace('{studentId}', studentId);
-        await getList<Group>(endpoint, groups, Group.fromJSON);
+        await getList<Group>(endpoint, groups, Group.fromJSON, selfProcessError);
     }
 
-    async function getGroupByStudentProject(projectId: string): Promise<void> {
+    async function getGroupByStudentProject(projectId: string, selfProcessError: boolean = false): Promise<void> {
         const endpoint = endpoints.groups.byProjectStudent.replace('{projectId}', projectId);
-        await get<Group>(endpoint, group, Group.fromJSON);
+        await get<Group>(endpoint, group, Group.fromJSON, selfProcessError);
     }
 
-    async function createGroup(groupData: Group, projectId: string): Promise<void> {
+    async function createGroup(groupData: Group, projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byProject.replace('{projectId}', projectId);
         await create<Group>(
             endpoint,
@@ -51,10 +51,12 @@ export function useGroup(): GroupState {
             },
             group,
             Group.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function updateGroup(groupData: Partial<Group>): Promise<void> {
+    async function updateGroup(groupData: Partial<Group>, selfProcessError: boolean = false): Promise<void> {
         if (groupData.id !== undefined) {
             const endpoint = endpoints.groups.retrieve.replace('{id}', groupData.id);
             await patch(
@@ -63,13 +65,14 @@ export function useGroup(): GroupState {
                     score: groupData.score,
                 },
                 response,
+                selfProcessError,
             );
         }
     }
 
-    async function deleteGroup(id: string): Promise<void> {
+    async function deleteGroup(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.retrieve.replace('{id}', id);
-        await deleteId<Group>(endpoint, group, Group.fromJSON);
+        await deleteId<Group>(endpoint, group, Group.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/helpers.ts b/frontend/src/composables/services/helpers.ts
index a5ff033f..4eab55c7 100644
--- a/frontend/src/composables/services/helpers.ts
+++ b/frontend/src/composables/services/helpers.ts
@@ -14,7 +14,12 @@ import { type Filter } from '@/types/filter/Filter.ts';
  * @param ref
  * @param fromJson
  */
-export async function get<T>(endpoint: string, ref: Ref<T | null>, fromJson: (data: any) => T): Promise<void> {
+export async function get<T>(
+    endpoint: string,
+    ref: Ref<T | null>,
+    fromJson: (data: any) => T,
+    selfProcessError: boolean = true,
+): Promise<void> {
     try {
         const response = await client.get(endpoint);
 
@@ -22,9 +27,12 @@ export async function get<T>(endpoint: string, ref: Ref<T | null>, fromJson: (da
             ref.value = fromJson(response.data);
         }
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -43,6 +51,7 @@ export async function create<T>(
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
     contentType: string = 'application/json',
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.post(endpoint, data, {
@@ -52,9 +61,12 @@ export async function create<T>(
         });
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -96,6 +108,7 @@ export async function patch(
     data: any,
     ref: Ref<Response | null>,
     contentType: string = 'application/json',
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response: AxiosResponse<Response, any> = await client.patch(endpoint, data, {
@@ -105,9 +118,12 @@ export async function patch(
         });
         ref.value = Response.fromJSON(response.data);
     } catch (error: any) {
-        processError(error);
-        console.error(error);
-        throw error;
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -122,12 +138,22 @@ export async function put<T>(
     endpoint: string,
     data: T | string,
     contentType: string = 'application/json',
+    selfProcessError: boolean = true,
 ): Promise<void> {
-    await client.put(endpoint, data, {
-        headers: {
-            'Content-Type': contentType,
-        },
-    });
+    try {
+        await client.put(endpoint, data, {
+            headers: {
+                'Content-Type': contentType,
+            },
+        });
+    } catch (error: any) {
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
+    }
 }
 
 /**
@@ -137,14 +163,22 @@ export async function put<T>(
  * @param ref
  * @param fromJson
  */
-export async function deleteId<T>(endpoint: string, ref: Ref<T | null>, fromJson: (data: any) => T): Promise<void> {
+export async function deleteId<T>(
+    endpoint: string,
+    ref: Ref<T | null>,
+    fromJson: (data: any) => T,
+    selfProcessError: boolean = true,
+): Promise<void> {
     try {
         const response = await client.delete(endpoint);
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -161,14 +195,18 @@ export async function deleteIdWithData<T>(
     data: any,
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.delete(endpoint, { data });
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -179,15 +217,23 @@ export async function deleteIdWithData<T>(
  * @param ref
  * @param fromJson
  */
-export async function getList<T>(endpoint: string, ref: Ref<T[] | null>, fromJson: (data: any) => T): Promise<void> {
+export async function getList<T>(
+    endpoint: string,
+    ref: Ref<T[] | null>,
+    fromJson: (data: any) => T,
+    selfProcessError: boolean = true,
+): Promise<void> {
     try {
         const response = await client.get(endpoint);
         ref.value = response.data.map((data: T) => fromJson(data));
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
         ref.value = []; // Set the ref to an empty array
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
@@ -208,6 +254,7 @@ export async function getPaginatedList<T>(
     pageSize: number,
     pagination: Ref<PaginatorResponse<T> | null>,
     fromJson: (data: any) => T,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.get(endpoint, {
@@ -223,9 +270,6 @@ export async function getPaginatedList<T>(
             results: response.data.results.map((data: T) => fromJson(data)),
         };
     } catch (error: any) {
-        processError(error);
-        console.error(error); // Log the error for debugging
-
         pagination.value = {
             // Set the ref to an empty array
             ...error.data,
@@ -233,7 +277,12 @@ export async function getPaginatedList<T>(
             results: [],
         };
 
-        throw error; // Re-throw the error to the caller
+        if (selfProcessError) {
+            processError(error);
+            console.error(error); // Log the error for debugging
+        } else {
+            throw error; // Re-throw the error to the caller
+        }
     }
 }
 
diff --git a/frontend/src/composables/services/project.service.ts b/frontend/src/composables/services/project.service.ts
index dd045d52..05e2f713 100644
--- a/frontend/src/composables/services/project.service.ts
+++ b/frontend/src/composables/services/project.service.ts
@@ -1,24 +1,28 @@
-import { Project, type ProjectJSON } from '@/types/Project';
+import { Project } from '@/types/Project';
 import { type Ref, ref } from 'vue';
 import { endpoints } from '@/config/endpoints.ts';
 import { i18n } from '@/config/i18n.ts';
-import axios from 'axios';
-import { create, deleteId, get, getList, patch, processError } from '@/composables/services/helpers.ts';
+import { create, deleteId, get, getList, patch } from '@/composables/services/helpers.ts';
 import { type Response } from '@/types/Response.ts';
 import { useMessagesStore } from '@/store/messages.store.ts';
 
 interface ProjectState {
     projects: Ref<Project[] | null>;
     project: Ref<Project | null>;
-    getProjectByID: (id: string) => Promise<void>;
-    getProjectsByCourse: (courseId: string) => Promise<void>;
-    getProjectsByStudent: (studentId: string) => Promise<void>;
-    getProjectsByAssistant: (assistantId: string) => Promise<void>;
-    getProjectsByTeacher: (teacherId: string) => Promise<void>;
-    getProjectsByCourseAndDeadline: (courseId: string, deadlineDate: Date) => Promise<void>;
-    createProject: (projectData: Project, courseId: string, numberOfGroups: number) => Promise<void>;
-    updateProject: (projectData: Project) => Promise<void>;
-    deleteProject: (id: string) => Promise<void>;
+    getProjectByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByAssistant: (assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByTeacher: (teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByCourseAndDeadline: (courseId: string, deadlineDate: Date, selfProcessError?: boolean) => Promise<void>;
+    createProject: (
+        projectData: Project,
+        courseId: string,
+        numberOfGroups: number,
+        selfProcessError?: boolean,
+    ) => Promise<void>;
+    updateProject: (projectData: Project, selfProcessError?: boolean) => Promise<void>;
+    deleteProject: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useProject(): ProjectState {
@@ -26,56 +30,51 @@ export function useProject(): ProjectState {
     const project = ref<Project | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getProjectByID(id: string): Promise<void> {
+    async function getProjectByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', id);
-        await get<Project>(endpoint, project, Project.fromJSON);
+        await get<Project>(endpoint, project, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByCourse(courseId: string): Promise<void> {
+    async function getProjectsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byCourse.replace('{courseId}', courseId);
-        await getList<Project>(endpoint, projects, Project.fromJSON);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByStudent(studentId: string): Promise<void> {
+    async function getProjectsByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byStudent.replace('{studentId}', studentId);
-        await getList<Project>(endpoint, projects, Project.fromJSON);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByAssistant(assistantId: string): Promise<void> {
+    async function getProjectsByAssistant(assistantId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byAssistant.replace('{assistantId}', assistantId);
-        await getList<Project>(endpoint, projects, Project.fromJSON);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByTeacher(teacherId: string): Promise<void> {
+    async function getProjectsByTeacher(teacherId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byTeacher.replace('{teacherId}', teacherId);
-        await getList<Project>(endpoint, projects, Project.fromJSON);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByCourseAndDeadline(courseId: string, deadlineDate: Date): Promise<void> {
-        const endpoint = endpoints.projects.byCourse.replace('{courseId}', courseId);
+    async function getProjectsByCourseAndDeadline(
+        courseId: string,
+        deadlineDate: Date,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
+        await getProjectsByCourse(courseId, selfProcessError);
 
-        await axios
-            .get(endpoint)
-            .then((response) => {
-                const allProjects = response.data.map((projectData: ProjectJSON) => Project.fromJSON(projectData));
-
-                // Filter projects based on the deadline date
-                // Update the projects ref with the filtered projects
-                projects.value = allProjects.filter((project: Project) => {
-                    return project.deadline.toDateString() === deadlineDate.toDateString();
-                });
-            })
-            .catch((error) => {
-                if (axios.isAxiosError(error)) {
-                    processError(error);
-                    console.log(error.response?.data);
-                } else {
-                    console.error('An unexpected error ocurred: ', error);
-                }
+        if (projects.value !== null) {
+            projects.value = projects.value.filter((project: Project) => {
+                return project.deadline.toDateString() === deadlineDate.toDateString();
             });
+        }
     }
 
-    async function createProject(projectData: Project, courseId: string, numberOfGroups: number): Promise<void> {
+    async function createProject(
+        projectData: Project,
+        courseId: string,
+        numberOfGroups: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const { t } = i18n.global;
         const { addSuccessMessage } = useMessagesStore();
 
@@ -100,14 +99,21 @@ export function useProject(): ProjectState {
             requestData.number_groups = numberOfGroups;
         }
 
-        await create<Project>(endpoint, requestData, project, Project.fromJSON, 'multipart/form-data');
+        await create<Project>(
+            endpoint,
+            requestData,
+            project,
+            Project.fromJSON,
+            'multipart/form-data',
+            selfProcessError,
+        );
         addSuccessMessage(
             t('toasts.messages.success'),
             t('toasts.messages.projects.create.success', [project.value?.name]),
         );
     }
 
-    async function updateProject(projectData: Project): Promise<void> {
+    async function updateProject(projectData: Project, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', projectData.id);
         await patch(
             endpoint,
@@ -125,12 +131,13 @@ export function useProject(): ProjectState {
             },
             response,
             'multipart/form-data',
+            selfProcessError,
         );
     }
 
-    async function deleteProject(id: string): Promise<void> {
+    async function deleteProject(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', id);
-        await deleteId<Project>(endpoint, project, Project.fromJSON);
+        await deleteId<Project>(endpoint, project, Project.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/structure_check.service.ts b/frontend/src/composables/services/structure_check.service.ts
index 405cb07c..fa1df7fe 100644
--- a/frontend/src/composables/services/structure_check.service.ts
+++ b/frontend/src/composables/services/structure_check.service.ts
@@ -6,28 +6,41 @@ import { get, getList, createToast, deleteId, put } from '@/composables/services
 interface StructureCheckState {
     structureChecks: Ref<StructureCheck[] | null>;
     structureCheck: Ref<StructureCheck | null>;
-    getStructureCheckByID: (id: string) => Promise<void>;
-    getStructureCheckByProject: (projectId: string) => Promise<void>;
-    createStructureCheck: (structureCheckData: StructureCheck, projectId: string) => Promise<void>;
-    setStructureChecks: (structureChecks: StructureCheck[], projectId: string) => Promise<void>;
-    deleteStructureCheck: (id: string) => Promise<void>;
+
+    getStructureCheckByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getStructureCheckByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    createStructureCheck: (
+        structureCheckData: StructureCheck,
+        projectId: string,
+        selfProcessError?: boolean,
+    ) => Promise<void>;
+    setStructureChecks: (
+        structureChecks: StructureCheck[],
+        projectId: string,
+        selfProcessError?: boolean,
+    ) => Promise<void>;
+    deleteStructureCheck: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useStructureCheck(): StructureCheckState {
     const structureChecks = ref<StructureCheck[] | null>(null);
     const structureCheck = ref<StructureCheck | null>(null);
 
-    async function getStructureCheckByID(id: string): Promise<void> {
+    async function getStructureCheckByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.retrieve.replace('{id}', id);
-        await get<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON);
+        await get<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfProcessError);
     }
 
-    async function getStructureCheckByProject(projectId: string): Promise<void> {
+    async function getStructureCheckByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
-        await getList<StructureCheck>(endpoint, structureChecks, StructureCheck.fromJSON);
+        await getList<StructureCheck>(endpoint, structureChecks, StructureCheck.fromJSON, selfProcessError);
     }
 
-    async function createStructureCheck(structureCheckData: StructureCheck, projectId: string): Promise<void> {
+    async function createStructureCheck(
+        structureCheckData: StructureCheck,
+        projectId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
         await createToast<StructureCheck>(
             'structureCheck',
@@ -37,17 +50,23 @@ export function useStructureCheck(): StructureCheckState {
             },
             structureCheck,
             StructureCheck.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function setStructureChecks(structureChecks: StructureCheck[], projectId: string): Promise<void> {
+    async function setStructureChecks(
+        structureChecks: StructureCheck[],
+        projectId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
-        await put(endpoint, structureChecks);
+        await put(endpoint, structureChecks, undefined, selfProcessError);
     }
 
-    async function deleteStructureCheck(id: string): Promise<void> {
+    async function deleteStructureCheck(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.retrieve.replace('{id}', id);
-        await deleteId<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON);
+        await deleteId<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/student.service.ts b/frontend/src/composables/services/student.service.ts
index 713ac8d3..f12cf6d6 100644
--- a/frontend/src/composables/services/student.service.ts
+++ b/frontend/src/composables/services/student.service.ts
@@ -8,16 +8,16 @@ interface StudentsState {
     students: Ref<Student[] | null>;
     student: Ref<Student | null>;
     response: Ref<Response | null>;
-    getStudentByID: (id: string, init?: boolean) => Promise<void>;
-    getStudents: () => Promise<void>;
-    getStudentsByCourse: (courseId: string) => Promise<void>;
-    getStudentsByGroup: (groupId: string) => Promise<void>;
-    createStudent: (studentData: Student) => Promise<void>;
-    deleteStudent: (id: string) => Promise<void>;
-    studentJoinCourse: (courseId: string, studentId: string) => Promise<void>;
-    studentLeaveCourse: (courseId: string, studentId: string) => Promise<void>;
-    studentJoinGroup: (groupId: string, studentId: string) => Promise<void>;
-    studentLeaveGroup: (groupId: string, studentId: string) => Promise<void>;
+    getStudentByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getStudents: (selfProcessError?: boolean) => Promise<void>;
+    getStudentsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getStudentsByGroup: (groupId: string, selfProcessError?: boolean) => Promise<void>;
+    createStudent: (studentData: Student, selfProcessError?: boolean) => Promise<void>;
+    deleteStudent: (id: string, selfProcessError?: boolean) => Promise<void>;
+    studentJoinCourse: (courseId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentLeaveCourse: (courseId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentJoinGroup: (groupId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentLeaveGroup: (groupId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useStudents(): StudentsState {
@@ -26,47 +26,89 @@ export function useStudents(): StudentsState {
     const student = ref<Student | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getStudentByID(id: string): Promise<void> {
+    async function getStudentByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.retrieve.replace('{id}', id);
-        await get<Student>(endpoint, student, Student.fromJSON);
+        await get<Student>(endpoint, student, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudents(): Promise<void> {
+    async function getStudents(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.index;
-        await getList<Student>(endpoint, students, Student.fromJSON);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudentsByCourse(courseId: string): Promise<void> {
+    async function getStudentsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
-        await getList<Student>(endpoint, students, Student.fromJSON);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudentsByGroup(groupId: string): Promise<void> {
+    async function getStudentsByGroup(groupId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
-        await getList<Student>(endpoint, students, Student.fromJSON);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
-    async function studentJoinCourse(courseId: string, studentId: string): Promise<void> {
+    async function studentJoinCourse(
+        courseId: string,
+        studentId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
-        await create<Response>(endpoint, { student: studentId }, response, Response.fromJSON);
+        await create<Response>(
+            endpoint,
+            { student: studentId },
+            response,
+            Response.fromJSON,
+            undefined,
+            selfProcessError,
+        );
     }
 
-    async function studentLeaveCourse(courseId: string, studentId: string): Promise<void> {
+    async function studentLeaveCourse(
+        courseId: string,
+        studentId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
-        await deleteIdWithData<Response>(endpoint, { student: studentId }, response, Response.fromJSON);
+        await deleteIdWithData<Response>(
+            endpoint,
+            { student: studentId },
+            response,
+            Response.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function studentJoinGroup(groupId: string, studentId: string): Promise<void> {
+    async function studentJoinGroup(
+        groupId: string,
+        studentId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
-        await create<Response>(endpoint, { student: studentId }, response, Response.fromJSON);
+        await create<Response>(
+            endpoint,
+            { student: studentId },
+            response,
+            Response.fromJSON,
+            undefined,
+            selfProcessError,
+        );
     }
 
-    async function studentLeaveGroup(groupId: string, studentId: string): Promise<void> {
+    async function studentLeaveGroup(
+        groupId: string,
+        studentId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
-        await deleteIdWithData<Response>(endpoint, { student: studentId }, response, Response.fromJSON);
+        await deleteIdWithData<Response>(
+            endpoint,
+            { student: studentId },
+            response,
+            Response.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function createStudent(studentData: Student): Promise<void> {
+    async function createStudent(studentData: Student, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.index;
 
         await createToast<Student>(
@@ -78,12 +120,14 @@ export function useStudents(): StudentsState {
             },
             student,
             Student.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteStudent(id: string): Promise<void> {
+    async function deleteStudent(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.retrieve.replace('{id}', id);
-        await deleteId<Student>(endpoint, student, Student.fromJSON);
+        await deleteId<Student>(endpoint, student, Student.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/submission.service.ts b/frontend/src/composables/services/submission.service.ts
index 261598c9..2387d0a2 100644
--- a/frontend/src/composables/services/submission.service.ts
+++ b/frontend/src/composables/services/submission.service.ts
@@ -8,33 +8,37 @@ import { useMessagesStore } from '@/store/messages.store.ts';
 interface SubmissionState {
     submissions: Ref<Submission[] | null>;
     submission: Ref<Submission | null>;
-    getSubmissionByID: (id: string) => Promise<void>;
-    getSubmissionByProject: (projectId: string) => Promise<void>;
-    getSubmissionByGroup: (groupId: string) => Promise<void>;
-    createSubmission: (submissionData: UnwrapRef<File[]>, groupId: string) => Promise<void>;
-    deleteSubmission: (id: string) => Promise<void>;
+    getSubmissionByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getSubmissionByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    getSubmissionByGroup: (groupId: string, selfProcessError?: boolean) => Promise<void>;
+    createSubmission: (submissionData: UnwrapRef<File[]>, groupId: string, selfProcessError?: boolean) => Promise<void>;
+    deleteSubmission: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useSubmission(): SubmissionState {
     const submissions = ref<Submission[] | null>(null);
     const submission = ref<Submission | null>(null);
 
-    async function getSubmissionByID(id: string): Promise<void> {
+    async function getSubmissionByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.retrieve.replace('{id}', id);
-        await get<Submission>(endpoint, submission, Submission.fromJSON);
+        await get<Submission>(endpoint, submission, Submission.fromJSON, selfProcessError);
     }
 
-    async function getSubmissionByProject(projectId: string): Promise<void> {
+    async function getSubmissionByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.byProject.replace('{projectId}', projectId);
-        await getList<Submission>(endpoint, submissions, Submission.fromJSON);
+        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfProcessError);
     }
 
-    async function getSubmissionByGroup(groupId: string): Promise<void> {
+    async function getSubmissionByGroup(groupId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.byGroup.replace('{groupId}', groupId);
-        await getList<Submission>(endpoint, submissions, Submission.fromJSON);
+        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfProcessError);
     }
 
-    async function createSubmission(uploadedFiles: File[], groupId: string): Promise<void> {
+    async function createSubmission(
+        uploadedFiles: File[],
+        groupId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const { t } = i18n.global;
         const { addSuccessMessage } = useMessagesStore();
 
@@ -44,14 +48,13 @@ export function useSubmission(): SubmissionState {
         uploadedFiles.forEach((file: File) => {
             formData.append('files', file); // Gebruik 'files' in plaats van 'files[]'
         });
-
-        await create(endpoint, formData, submission, Submission.fromJSON, 'multipart/form-data');
+        await create(endpoint, formData, submission, Submission.fromJSON, 'multipart/form-data', selfProcessError);
         addSuccessMessage(t('toasts.messages.success'), t('toasts.messages.submissions.create.success'));
     }
 
-    async function deleteSubmission(id: string): Promise<void> {
+    async function deleteSubmission(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.retrieve.replace('{id}', id);
-        await deleteId<Submission>(endpoint, submission, Submission.fromJSON);
+        await deleteId<Submission>(endpoint, submission, Submission.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/submission_status.service.ts b/frontend/src/composables/services/submission_status.service.ts
index 77174b7a..e63cb176 100644
--- a/frontend/src/composables/services/submission_status.service.ts
+++ b/frontend/src/composables/services/submission_status.service.ts
@@ -5,15 +5,15 @@ import { SubmissionStatus } from '@/types/SubmisionStatus';
 
 interface SubmissionStatusState {
     submissionStatus: Ref<SubmissionStatus | null>;
-    getSubmissionStatusByProject: (projectId: string) => Promise<void>;
+    getSubmissionStatusByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useSubmissionStatus(): SubmissionStatusState {
     const submissionStatus = ref<SubmissionStatus | null>(null);
 
-    async function getSubmissionStatusByProject(projectId: string): Promise<void> {
+    async function getSubmissionStatusByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.status.replace('{projectId}', projectId);
-        await get<SubmissionStatus>(endpoint, submissionStatus, SubmissionStatus.fromJSON);
+        await get<SubmissionStatus>(endpoint, submissionStatus, SubmissionStatus.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/teacher.service.ts b/frontend/src/composables/services/teacher.service.ts
index 708ca51c..f25583c5 100644
--- a/frontend/src/composables/services/teacher.service.ts
+++ b/frontend/src/composables/services/teacher.service.ts
@@ -21,14 +21,14 @@ interface TeacherState {
     teacher: Ref<Teacher | null>;
     response: Ref<Response | null>;
     teacherPagination: Ref<PaginatorResponse<Teacher> | null>;
-    getTeacherByID: (id: string, init?: boolean) => Promise<void>;
-    getTeachersByCourse: (courseId: string) => Promise<void>;
-    getTeachers: () => Promise<void>;
-    searchTeachers: (filters: Filter, page: number, pageSize: number) => Promise<void>;
-    teacherJoinCourse: (courseId: string, teacherId: string) => Promise<void>;
-    teacherLeaveCourse: (courseId: string, teacherId: string) => Promise<void>;
-    createTeacher: (teacherData: Teacher) => Promise<void>;
-    deleteTeacher: (id: string) => Promise<void>;
+    getTeacherByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getTeachersByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getTeachers: (selfProcessError?: boolean) => Promise<void>;
+    searchTeachers: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    teacherJoinCourse: (courseId: string, teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    teacherLeaveCourse: (courseId: string, teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    createTeacher: (teacherData: Teacher, selfProcessError?: boolean) => Promise<void>;
+    deleteTeacher: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useTeacher(): TeacherState {
@@ -38,37 +38,71 @@ export function useTeacher(): TeacherState {
     const response = ref<Response | null>(null);
     const teacherPagination = ref<PaginatorResponse<Teacher> | null>(null);
 
-    async function getTeacherByID(id: string): Promise<void> {
+    async function getTeacherByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.retrieve.replace('{id}', id);
-        await get<Teacher>(endpoint, teacher, Teacher.fromJSON);
+        await get<Teacher>(endpoint, teacher, Teacher.fromJSON, selfProcessError);
     }
 
-    async function getTeachersByCourse(courseId: string): Promise<void> {
+    async function getTeachersByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
-        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON);
+        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfProcessError);
     }
 
-    async function getTeachers(): Promise<void> {
+    async function getTeachers(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.index;
-        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON);
+        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfProcessError);
     }
 
-    async function searchTeachers(filters: Filter, page: number, pageSize: number): Promise<void> {
+    async function searchTeachers(
+        filters: Filter,
+        page: number,
+        pageSize: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.teachers.search;
-        await getPaginatedList<Teacher>(endpoint, filters, page, pageSize, teacherPagination, Teacher.fromJSON);
+        await getPaginatedList<Teacher>(
+            endpoint,
+            filters,
+            page,
+            pageSize,
+            teacherPagination,
+            Teacher.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function teacherJoinCourse(courseId: string, teacherId: string): Promise<void> {
+    async function teacherJoinCourse(
+        courseId: string,
+        teacherId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
-        await create<Response>(endpoint, { teacher: teacherId }, response, Response.fromJSON);
+        await create<Response>(
+            endpoint,
+            { teacher: teacherId },
+            response,
+            Response.fromJSON,
+            undefined,
+            selfProcessError,
+        );
     }
 
-    async function teacherLeaveCourse(courseId: string, teacherId: string): Promise<void> {
+    async function teacherLeaveCourse(
+        courseId: string,
+        teacherId: string,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
-        await deleteIdWithData<Response>(endpoint, { teacher: teacherId }, response, Response.fromJSON);
+        await deleteIdWithData<Response>(
+            endpoint,
+            { teacher: teacherId },
+            response,
+            Response.fromJSON,
+            selfProcessError,
+        );
     }
 
-    async function createTeacher(user: User): Promise<void> {
+    async function createTeacher(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.index;
         await createToast<Teacher>(
             'teacher',
@@ -78,12 +112,14 @@ export function useTeacher(): TeacherState {
             },
             teacher,
             Teacher.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function deleteTeacher(id: string): Promise<void> {
+    async function deleteTeacher(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.retrieve.replace('{id}', id);
-        await deleteId<Teacher>(endpoint, teacher, Teacher.fromJSON);
+        await deleteId<Teacher>(endpoint, teacher, Teacher.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/users.service.ts b/frontend/src/composables/services/users.service.ts
index 565e5967..1f6bfaf9 100644
--- a/frontend/src/composables/services/users.service.ts
+++ b/frontend/src/composables/services/users.service.ts
@@ -10,11 +10,11 @@ interface userState {
     pagination: Ref<PaginatorResponse<User> | null>;
     users: Ref<User[] | null>;
     user: Ref<User | null>;
-    getUserByID: (id: string) => Promise<void>;
-    getUsers: () => Promise<void>;
-    searchUsers: (filters: Filter, page: number, pageSize: number) => Promise<void>;
-    createUser: (user_data: User) => Promise<void>;
-    toggleAdmin: (id: string, is_staff: boolean) => Promise<void>;
+    getUserByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getUsers: (selfProcessError?: boolean) => Promise<void>;
+    searchUsers: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    createUser: (user_data: User, selfProcessError?: boolean) => Promise<void>;
+    toggleAdmin: (id: string, is_staff: boolean, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useUser(): userState {
@@ -23,22 +23,27 @@ export function useUser(): userState {
     const user = ref<User | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getUserByID(id: string): Promise<void> {
+    async function getUserByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.retrieve.replace('{id}', id);
-        await get<User>(endpoint, user, User.fromJSON);
+        await get<User>(endpoint, user, User.fromJSON, selfProcessError);
     }
 
-    async function getUsers(): Promise<void> {
+    async function getUsers(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.index;
-        await getList<User>(endpoint, users, User.fromJSON);
+        await getList<User>(endpoint, users, User.fromJSON, selfProcessError);
     }
 
-    async function searchUsers(filters: Filter, page: number, pageSize: number): Promise<void> {
+    async function searchUsers(
+        filters: Filter,
+        page: number,
+        pageSize: number,
+        selfProcessError: boolean = true,
+    ): Promise<void> {
         const endpoint = endpoints.users.search;
-        await getPaginatedList<User>(endpoint, filters, page, pageSize, pagination, User.fromJSON);
+        await getPaginatedList<User>(endpoint, filters, page, pageSize, pagination, User.fromJSON, selfProcessError);
     }
 
-    async function createUser(userData: User): Promise<void> {
+    async function createUser(userData: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.index;
         await createToast<User>(
             'user',
@@ -52,10 +57,12 @@ export function useUser(): userState {
             },
             user,
             User.fromJSON,
+            undefined,
+            selfProcessError,
         );
     }
 
-    async function toggleAdmin(id: string, isStaff: boolean): Promise<void> {
+    async function toggleAdmin(id: string, isStaff: boolean, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.admin.replace('{id}', id);
         await patch(
             endpoint,
@@ -63,6 +70,8 @@ export function useUser(): userState {
                 is_staff: isStaff,
             },
             response,
+            undefined,
+            selfProcessError,
         );
     }
 
diff --git a/frontend/src/views/courses/CreateCourseView.vue b/frontend/src/views/courses/CreateCourseView.vue
index 20cf69e4..d78b3e9c 100644
--- a/frontend/src/views/courses/CreateCourseView.vue
+++ b/frontend/src/views/courses/CreateCourseView.vue
@@ -9,9 +9,11 @@ import { useFaculty } from '@/composables/services/faculty.service.ts';
 import { type Course } from '@/types/Course.ts';
 import { useCourses } from '@/composables/services/course.service.ts';
 import { useRouter } from 'vue-router';
+import { useMessagesStore } from '@/store/messages.store.ts';
 
 /* Composable injections */
 const { t } = useI18n();
+const { addSuccessMessage } = useMessagesStore();
 const { push } = useRouter();
 const { faculties, getFaculties } = useFaculty();
 const { createCourse } = useCourses();
@@ -25,8 +27,13 @@ const loading = ref(true);
  * @param course
  */
 async function saveCourse(course: Course): Promise<void> {
-    await createCourse(course);
-    await push({ name: 'dashboard' });
+    try {
+        await createCourse(course);
+        addSuccessMessage(t('toasts.messages.success'), t('toasts.messages.courses.create.success', [course.name]));
+        await push({ name: 'dashboard' });
+    } catch (error: any) {
+        // TODO error message
+    }
 }
 
 /** Load the data */