diff --git a/controller/auth/kratos.py b/controller/auth/kratos.py
index 6c7fa5e2..5b1183e4 100644
--- a/controller/auth/kratos.py
+++ b/controller/auth/kratos.py
@@ -152,7 +152,7 @@ def resolve_user_mail_by_id(user_id: str) -> str:
     return None
 
 
-def resolve_user_name_by_id(user_id: str) -> str:
+def resolve_user_name_by_id(user_id: str) -> Dict[str, str]:
     i = __get_identity(user_id, False)
     if i:
         i = i["identity"]
diff --git a/controller/embedding/manager.py b/controller/embedding/manager.py
index 38bb6a2a..6f5ee4a8 100644
--- a/controller/embedding/manager.py
+++ b/controller/embedding/manager.py
@@ -5,7 +5,6 @@
 from submodules.model import enums
 from submodules.model.models import Embedding
 from util import notification
-from . import util
 from . import connector
 from .terms import TERMS_INFO
 from controller.model_provider import manager as model_manager
@@ -14,11 +13,8 @@
     embedding,
     agreement,
     general,
-    project,
 )
 from submodules.model import daemon
-from submodules.model.util import sql_alchemy_to_dict
-from controller.embedding.connector import collection_on_qdrant
 
 
 def get_terms_info(
@@ -29,19 +25,6 @@ def get_terms_info(
     return list(TERMS_INFO.values())
 
 
-def get_current_terms_text(
-    platform: str,
-) -> Optional[str]:
-    terms = TERMS_INFO[platform]
-    term_text = terms.get("terms")
-    if not term_text:
-        return None
-    link = terms.get("link")
-    if link:
-        term_text = term_text.replace("@@PLACEHOLDER@@", link)
-    return term_text
-
-
 def get_recommended_encoders() -> List[Any]:
     # can run into circular import problems if directly resolved here by helper method
     recommendations = connector.request_listing_recommended_encoders()
@@ -71,17 +54,6 @@ def get_recommended_encoders() -> List[Any]:
     return recommendations
 
 
-def create_embedding(project_id: str, embedding_id: str) -> None:
-    daemon.run_without_db_token(connector.request_embedding, project_id, embedding_id)
-
-
-def create_embeddings_one_by_one(
-    project_id: str,
-    embeddings_ids: List[str],
-) -> None:
-    daemon.run_without_db_token(__embed_one_by_one_helper, project_id, embeddings_ids)
-
-
 def request_tensor_upload(project_id: str, embedding_id: str) -> Any:
     connector.request_tensor_upload(project_id, embedding_id)
 
@@ -92,21 +64,6 @@ def delete_embedding(project_id: str, embedding_id: str) -> None:
     connector.request_deleting_embedding(project_id, embedding_id)
 
 
-def __embed_one_by_one_helper(project_id: str, embeddings_ids: List[str]) -> None:
-    ctx_token = general.get_ctx_token()
-    for embedding_id in embeddings_ids:
-        connector.request_embedding(project_id, embedding_id)
-        time.sleep(5)
-        c = 1
-        while util.has_encoder_running(project_id):
-            c += 1
-            if c > 12:
-                ctx_token = general.remove_and_refresh_session(ctx_token, True)
-                c = 1
-            time.sleep(5)
-    general.remove_and_refresh_session(ctx_token, False)
-
-
 def get_embedding_name(
     project_id: str,
     attribute_id: str,
@@ -142,62 +99,6 @@ def get_embedding_name(
     return name
 
 
-EMBEDDING_SCHEMA_WHITELIST = [
-    "id",
-    "name",
-    "custom",
-    "type",
-    "state",
-    "progress",
-    "dimension",
-    "count",
-    "platform",
-    "model",
-    "filter_attributes",
-    "attribute_id",
-]
-
-
-def get_embedding_schema(project_id: str) -> List[Dict[str, Any]]:
-    embeddings = embedding.get_all_embeddings_by_project_id(project_id)
-    embedding_dict = sql_alchemy_to_dict(
-        embeddings, column_whitelist=EMBEDDING_SCHEMA_WHITELIST
-    )
-    number_records = len(project.get(project_id).records)
-    expanded_embeddings = []
-    for embed in embedding_dict:
-        count = embedding.get_tensor_count(embed["id"])
-        onQdrant = collection_on_qdrant(project_id, embed["id"])
-
-        embedding_item = embedding.get_tensor(embed["id"])
-        dimension = 0
-        if embedding_item is not None:
-            # distinguish between token and attribute embeddings
-            if type(embedding_item.data[0]) is list:
-                dimension = len(embedding_item.data[0])
-            else:
-                dimension = len(embedding_item.data)
-
-        if embed["state"] == "FINISHED":
-            progress = 1
-        elif embed["state"] == "INITIALIZING" or embed["state"] == "WAITING":
-            progress = 0.0
-        else:
-            progress = min(
-                0.1 + (count / number_records * 0.9),
-                0.99,
-            )
-        expanded_embed = {
-            **embed,
-            "progress": progress,
-            "count": count,
-            "dimension": dimension,
-            "onQdrant": onQdrant,
-        }
-        expanded_embeddings.append(expanded_embed)
-    return {"id": project_id, "embeddings": expanded_embeddings}
-
-
 def recreate_embeddings(
     project_id: str, embedding_ids: Optional[List[str]] = None, user_id: str = None
 ) -> None:
diff --git a/controller/embedding/util.py b/controller/embedding/util.py
deleted file mode 100644
index a7cb733f..00000000
--- a/controller/embedding/util.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from submodules.model.business_objects import embedding
-
-
-def has_encoder_running(project_id: str) -> bool:
-    return embedding.get_first_running_encoder(project_id) is not None
diff --git a/controller/transfer/manager.py b/controller/transfer/manager.py
index 098a9f79..8aefe780 100644
--- a/controller/transfer/manager.py
+++ b/controller/transfer/manager.py
@@ -1,8 +1,7 @@
 import os
 import logging
 import json
-import traceback
-from typing import Any, List, Optional, Dict
+from typing import Any, Optional, Dict
 
 from controller.transfer import export_parser
 from controller.transfer.knowledge_base_transfer_manager import (
@@ -23,7 +22,6 @@
     record_label_association,
     data_slice,
     knowledge_base,
-    upload_task,
 )
 from submodules.model.business_objects import general
 from controller.upload_task import manager as upload_task_manager
@@ -35,11 +33,6 @@
 from controller.labeling_task import manager as labeling_task_manager
 from controller.labeling_task_label import manager as labeling_task_label_manager
 from submodules.model.business_objects import record_label_association as rla
-from controller.task_master import manager as task_master_manager
-from submodules.model.enums import TaskType, RecordTokenizationScope
-
-
-from util.notification import create_notification
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
@@ -65,7 +58,9 @@ def get_upload_credentials_and_id(
         key,
     )
     org_id = organization.get_id_by_project_id(project_id)
-    return s3.get_upload_credentials_and_id(org_id, project_id + "/" + str(task.id))
+    return s3.get_upload_credentials_and_id(
+        org_id, project_id + "/" + str(task.id), True, True
+    )
 
 
 def import_records_from_file(project_id: str, task: UploadTask) -> None:
diff --git a/fast_api/routes/attribute.py b/fast_api/routes/attribute.py
index 8675e435..6b104d9a 100644
--- a/fast_api/routes/attribute.py
+++ b/fast_api/routes/attribute.py
@@ -2,7 +2,7 @@
 from controller.auth import manager as auth_manager
 from typing import List, Union
 from fast_api.models import DeleteUserAttributeBody
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 from fastapi import APIRouter, Body, Depends, Query, Request
 from submodules.model.enums import NotificationType
 from submodules.model.util import sql_alchemy_to_dict
@@ -34,7 +34,7 @@ def get_attributes(
 ):
     data = manager.get_all_attributes(project_id, state_filter)
     data_dict = sql_alchemy_to_dict(data, column_whitelist=ALL_ATTRIBUTES_WHITELIST)
-    return pack_json_result({"data": {"attributesByProjectId": data_dict}})
+    return pack_json_result(data_dict)
 
 
 @router.get(
@@ -54,7 +54,7 @@ def get_check_composite_key(
             project_id,
         )
 
-    return pack_json_result({"data": {"checkCompositeKey": is_valid}})
+    return pack_json_result(is_valid)
 
 
 @router.get(
@@ -71,12 +71,8 @@ def get_sample_records(
     )
     return pack_json_result(
         {
-            "data": {
-                "calculateUserAttributeSampleRecords": {
-                    "record_ids": record_ids,
-                    "calculated_attributes": calculated_attributes,
-                }
-            }
+            "record_ids": record_ids,
+            "calculated_attributes": calculated_attributes,
         }
     )
 
@@ -91,4 +87,4 @@ def delete_user_attribute(
     body: DeleteUserAttributeBody = Body(...),
 ):
     manager.delete_attribute(project_id, body.attribute_id)
-    return pack_json_result({"data": {"deleteUserAttribute": {"ok": True}}})
+    return get_silent_success()
diff --git a/fast_api/routes/client_response.py b/fast_api/routes/client_response.py
index 627daeaa..c09e45fe 100644
--- a/fast_api/routes/client_response.py
+++ b/fast_api/routes/client_response.py
@@ -60,5 +60,18 @@ def get_silent_success() -> JSONResponse:
     return SILENT_SUCCESS_RESPONSE
 
 
+def get_custom_response(status_code, content, type="text"):
+    if type == "json":
+        return JSONResponse(
+            status_code=status_code,
+            content=content,
+        )
+    else:
+        return PlainTextResponse(
+            status_code=status_code,
+            content=content,
+        )
+
+
 def to_json(obj: BaseModel):
     return json.loads(obj.json())
diff --git a/fast_api/routes/comment.py b/fast_api/routes/comment.py
index 3a979549..f59ff0de 100644
--- a/fast_api/routes/comment.py
+++ b/fast_api/routes/comment.py
@@ -6,12 +6,11 @@
     DeleteCommentBody,
     UpdateCommentBody,
 )
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 from submodules.model.enums import CommentCategory
 from util import notification
 from middleware.log_storage import extend_state_get_like
 
-
 router = APIRouter()
 
 
@@ -56,9 +55,7 @@ def get_all_comments(request: Request):
             "add_info": add_info,
         }
 
-    return pack_json_result(
-        {"data": {"getAllComments": to_return}}, wrap_for_frontend=False
-    )
+    return pack_json_result(to_return, wrap_for_frontend=False)
 
 
 @router.post("/create-comment")
@@ -84,7 +81,7 @@ def create_comment(request: Request, body: CreateCommentBody = Body(...)):
             True,
         )
 
-    return pack_json_result({"data": {"createComment": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete("/delete-comment")
@@ -109,7 +106,7 @@ def delete_comment(
             True,
         )
 
-    return pack_json_result({"data": {"deleteComment": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.put("/update-comment")
@@ -134,7 +131,7 @@ def update_comment(
             True,
         )
 
-    return pack_json_result({"data": {"updateComment": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.get("/get-unique-comments-keys-for")
diff --git a/fast_api/routes/data_browser.py b/fast_api/routes/data_browser.py
index 6c7de6d7..c759a790 100644
--- a/fast_api/routes/data_browser.py
+++ b/fast_api/routes/data_browser.py
@@ -1,6 +1,5 @@
 import json
 from fastapi import APIRouter, Body, Depends, Request
-from fastapi.responses import JSONResponse
 from controller.auth import manager as auth_manager
 from controller.record import manager as manager
 from controller.data_slice import manager as data_slice_manager
@@ -14,7 +13,11 @@
     SearchRecordsExtendedBody,
     UpdateDataSliceBody,
 )
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import (
+    pack_json_result,
+    get_silent_success,
+    GENERIC_FAILURE_RESPONSE,
+)
 from service.search.search import resolve_extended_search
 from submodules.model.business_objects import general
 from util import notification
@@ -42,9 +45,7 @@ def get_record_comments(
 
     user_id = auth_manager.get_user_id_by_info(request.state.info)
     data = comment_manager.get_record_comments(project_id, user_id, record_ids)
-    return pack_json_result(
-        {"data": {"getRecordComments": data}}, wrap_for_frontend=False
-    )
+    return pack_json_result(data, wrap_for_frontend=False)
 
 
 @router.post(
@@ -81,7 +82,7 @@ def search_records_extended(
         "sessionId": results.session_id,
     }
 
-    return pack_json_result({"data": {"searchRecordsExtended": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -113,7 +114,7 @@ def search_records_extended_cog(
         "recordList": record_list_pop,
     }
 
-    return pack_json_result({"data": {"searchRecordsExtended": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -142,10 +143,7 @@ def create_outlier_slice(
             project_id, f"data_slice_created:{str(data_slice_item.id)}"
         )
 
-    return JSONResponse(
-        status_code=201,
-        content={"message": "Outlier slice created"},
-    )
+    return get_silent_success()
 
 
 @router.post(
@@ -183,7 +181,7 @@ def get_records_by_static_slice(
         "sessionId": results.session_id,
     }
 
-    return pack_json_result({"data": {"recordsByStaticSlice": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -209,16 +207,11 @@ def create_data_slice(
         notification.send_organization_update(
             project_id, f"data_slice_created:{str(data_slice_item.id)}"
         )
-        data = {"id": str(data_slice_item.id), "__typename": "CreateDataSlice"}
-        return pack_json_result(
-            {"data": {"createDataSlice": data}}, wrap_for_frontend=False
-        )
+        data = {"id": str(data_slice_item.id)}
+        return pack_json_result(data, wrap_for_frontend=False)
     except Exception as e:
         handle_error(e, user.id, project_id)
-        return JSONResponse(
-            status_code=400,
-            content={"message": str(e)},
-        )
+        return GENERIC_FAILURE_RESPONSE
 
 
 @router.post(
@@ -256,7 +249,7 @@ def get_search_records_by_similarity(
         "sessionId": results.session_id,
     }
 
-    return pack_json_result({"data": {"searchRecordsBySimilarity": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -270,7 +263,6 @@ def update_data_slice(
 ):
 
     user = auth_manager.get_user_by_info(request.state.info)
-    ok = False
 
     try:
         raw = json.loads(dataSliceBody.filter_raw)
@@ -287,11 +279,11 @@ def update_data_slice(
         notification.send_organization_update(
             project_id, f"data_slice_updated:{dataSliceBody.data_slice_id}"
         )
-        ok = True
     except Exception as e:
         handle_error(e, user.id, project_id)
+        return GENERIC_FAILURE_RESPONSE
 
-    return pack_json_result({"data": {"updateDataSlice": {"ok": ok}}})
+    return get_silent_success()
 
 
 def handle_error(exception: Exception, user_id: str, project_id: str):
diff --git a/fast_api/routes/data_slices.py b/fast_api/routes/data_slices.py
index 04c6d586..4f237173 100644
--- a/fast_api/routes/data_slices.py
+++ b/fast_api/routes/data_slices.py
@@ -1,7 +1,7 @@
 from typing import Optional
 
 from fastapi import APIRouter, Depends, Request
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 from submodules.model.util import sql_alchemy_to_dict
 from typing import List
 from controller.data_slice import manager
@@ -34,9 +34,7 @@ def get_data_slices(
         v["filterRaw"] = json.dumps(v["filter_raw"])
         del v["count_sql"]
 
-    return pack_json_result(
-        {"data": {"dataSlices": values}},
-    )
+    return pack_json_result(values)
 
 
 @router.get(
@@ -45,9 +43,7 @@ def get_data_slices(
 )
 def get_unique_values_by_attributes(project_id: str):
     data = record_manager.get_unique_values_by_attributes(project_id)
-    return pack_json_result(
-        {"data": {"uniqueValuesByAttributes": data}}, wrap_for_frontend=False
-    )
+    return pack_json_result(data, wrap_for_frontend=False)
 
 
 @router.get(
@@ -60,7 +56,7 @@ def get_static_data_slices_current_count(
     slice_id: str,
 ):
     data = manager.count_items(project_id, slice_id)
-    return pack_json_result({"data": {"staticDataSlicesCurrentCount": data}})
+    return pack_json_result(data)
 
 
 @router.delete(
@@ -76,4 +72,4 @@ def delete_data_slice_by_id(
     notification.send_organization_update(
         project_id, f"data_slice_deleted:{data_slice_id}"
     )
-    return pack_json_result({"data": {"deleteDataSliceById": {"ok": True}}})
+    return get_silent_success()
diff --git a/fast_api/routes/embedding.py b/fast_api/routes/embedding.py
index 5c7d36d0..c18bb41f 100644
--- a/fast_api/routes/embedding.py
+++ b/fast_api/routes/embedding.py
@@ -1,19 +1,19 @@
 from typing import List, Optional
 
 from fast_api.models import CreateEmbeddingBody, UpdateEmbeddingBody
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import (
+    pack_json_result,
+    get_silent_success,
+    GENERIC_FAILURE_RESPONSE,
+)
 from fastapi import APIRouter, Body, Depends, Request
 from controller.embedding import manager
 from controller.task_master import manager as task_master_manager
 from controller.auth import manager as auth_manager
 from controller.embedding.connector import collection_on_qdrant
-from submodules.model.business_objects import project
-from submodules.model.business_objects.embedding import (
-    get_all_embeddings_by_project_id,
-    get_tensor_count,
-    get_tensor,
-)
 from submodules.model.enums import TaskType
+from submodules.model.business_objects import embedding
+from submodules.model.util import sql_alchemy_to_dict
 from util import notification, spacy_util
 import json
 
@@ -24,7 +24,7 @@
 @router.get("/embedding-platforms")
 def get_embedding_platforms():
     data = manager.get_terms_info()
-    return pack_json_result({"data": {"embeddingPlatforms": data}})
+    return pack_json_result(data)
 
 
 @router.get("/recommended-encoders")
@@ -32,14 +32,13 @@ def data_slices(request: Request, project_id: Optional[str] = None) -> List:
     data = manager.get_recommended_encoders()
     for v in data:
         v["applicability"] = json.dumps(v["applicability"])
-    return pack_json_result({"data": {"recommendedEncoders": data}})
+    return pack_json_result(data)
 
 
 @router.get("/language-models")
 def language_models(request: Request) -> List:
-    return pack_json_result(
-        {"data": {"languageModels": spacy_util.get_language_models()}}
-    )
+    data = spacy_util.get_language_models()
+    return pack_json_result(data)
 
 
 @router.get(
@@ -47,63 +46,17 @@ def language_models(request: Request) -> List:
     dependencies=[Depends(auth_manager.check_project_access_dep)],
 )
 def get_embeddings(project_id: str) -> List:
-    embeddings = get_all_embeddings_by_project_id(project_id)
-    number_records = len(project.get(project_id).records)
-
-    edges = []
-
-    for embedding in embeddings:
-
-        count = get_tensor_count(embedding.id)
-        on_qdrant = collection_on_qdrant(project_id, embedding.id)
-
-        embedding_item = get_tensor(embedding.id)
-        dimension = 0
-        if embedding_item is not None:
-            # distinguish between token and attribute embeddings
-            if type(embedding_item.data[0]) is list:
-                dimension = len(embedding_item.data[0])
-            else:
-                dimension = len(embedding_item.data)
-
-        if embedding.state == "FINISHED":
-            progress = 1
-        elif embedding.state == "INITIALIZING" or embedding.state == "WAITING":
-            progress = 0.0
-        else:
-            progress = min(
-                0.1 + (count / number_records * 0.9),
-                0.99,
-            )
-
-        edges.append(
-            {
-                "node": {
-                    "id": embedding.id,
-                    "name": embedding.name,
-                    "custom": embedding.custom,
-                    "type": embedding.type,
-                    "state": embedding.state,
-                    "platform": embedding.platform,
-                    "model": embedding.model,
-                    "filterAttributes": embedding.filter_attributes,
-                    "attributeId": embedding.attribute_id,
-                    "progress": progress,
-                    "dimension": dimension,
-                    "count": count,
-                    "onQdrant": on_qdrant,
-                }
-            }
-        )
-
-    data = {
-        "projectByProjectId": {
-            "id": project_id,
-            "embeddings": {"edges": edges},
+    embeddings_extended = embedding.get_all_embeddings_by_project_id_extended(
+        project_id
+    )
+    data = [
+        {
+            **sql_alchemy_to_dict(embedding),
+            "on_qdrant": collection_on_qdrant(project_id, embedding["id"]),
         }
-    }
-
-    return pack_json_result({"data": data})
+        for embedding in embeddings_extended
+    ]
+    return pack_json_result(data)
 
 
 @router.delete(
@@ -116,7 +69,7 @@ def delete_from_task_queue(
 ):
     org_id = auth_manager.get_user_by_info(request.state.info).organization_id
     task_master_manager.delete_task(org_id, task_id)
-    return pack_json_result({"data": {"deleteFromTaskQueue": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete(
@@ -132,7 +85,7 @@ def delete_embedding(
     notification.send_organization_update(
         project_id, f"embedding_deleted:{embedding_id}"
     )
-    return pack_json_result({"data": {"deleteEmbedding": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -192,7 +145,7 @@ def create_embedding(
     notification.send_organization_update(
         project_id=project_id, message="embedding:queued"
     )
-    return pack_json_result({"data": {"createEmbedding": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -213,5 +166,6 @@ def update_embedding_payload(
         notification.send_organization_update(
             project_id, f"embedding_updated:{updateEmbeddingBody.embedding_id}"
         )
-
-    return pack_json_result({"data": {"updateEmbeddingPayload": {"ok": went_through}}})
+        return get_silent_success()
+    else:
+        return GENERIC_FAILURE_RESPONSE
diff --git a/fast_api/routes/heuristic.py b/fast_api/routes/heuristic.py
index 7927dc5f..eedb2021 100644
--- a/fast_api/routes/heuristic.py
+++ b/fast_api/routes/heuristic.py
@@ -1,14 +1,13 @@
 from fast_api.models import CreateHeuristicBody, UpdateHeuristicBody
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 from fastapi import APIRouter, Body, Depends, Request
 from controller.information_source import manager
 from submodules.model.business_objects import weak_supervision
 from controller.auth import manager as auth_manager
-from controller.labeling_access_link import manager as access_link_manager
 from controller.payload import manager as payload_manager
 from submodules.model.business_objects import information_source
 from submodules.model.business_objects.payload import get_payload_with_heuristic_type
-from submodules.model.util import pack_edges_node, sql_alchemy_to_dict
+from submodules.model.util import sql_alchemy_to_dict
 from util import notification
 from controller.task_master import manager as task_master_manager
 from submodules.model import enums
@@ -26,7 +25,7 @@ def get_information_sources_overview_data(
     project_id: str,
 ):
     data = manager.get_overview_data(project_id)
-    return pack_json_result({"data": {"informationSourcesOverviewData": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -39,7 +38,7 @@ def get_weak_supervision_run(
 ):
     result = weak_supervision.get_current_weak_supervision_run(project_id)
     if result is None:
-        return pack_json_result({"data": {"currentWeakSupervisionRun": None}})
+        return pack_json_result(None)
 
     user_id = auth_manager.get_user_id_by_info(request.state.info)
     names, mail = kratos.resolve_user_name_and_email_by_id(user_id)
@@ -63,7 +62,7 @@ def get_weak_supervision_run(
         },
     }
 
-    return pack_json_result({"data": {"currentWeakSupervisionRun": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -79,15 +78,11 @@ def get_heuristic_by_heuristic_id(
             project_id, heuristic_id
         )
     )
-    statistics = pack_edges_node(
-        sql_alchemy_to_dict(
-            information_source.get_source_statistics(project_id, heuristic_id)
-        ),
-        "sourceStatistics",
+    statistics = sql_alchemy_to_dict(
+        information_source.get_source_statistics(project_id, heuristic_id)
     )
-    if statistics is not None:
-        data["sourceStatistics"] = statistics["data"]["sourceStatistics"]
-    return pack_json_result({"data": {"informationSourceBySourceId": data}})
+    data["sourceStatistics"] = statistics
+    return pack_json_result(data)
 
 
 @router.get(
@@ -99,7 +94,7 @@ def get_payload_by_payload_id(
     payload_id: str,
 ):
     data = sql_alchemy_to_dict(get_payload_with_heuristic_type(project_id, payload_id))
-    return pack_json_result({"data": {"payloadByPayloadId": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -111,27 +106,7 @@ def get_labeling_function_on_10_records(
     heuristic_id: str,
 ):
     data = payload_manager.get_labeling_function_on_10_records(project_id, heuristic_id)
-    return {"data": {"getLabelingFunctionOn10Records": data}}
-
-
-@router.get(
-    "/{project_id}/access-link",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def get_access_link(
-    request: Request,
-    project_id: str,
-    link_id: str,
-):
-    accessLink = access_link_manager.get(link_id)
-
-    data = {
-        "id": str(accessLink.id),
-        "link": accessLink.link,
-        "isLocked": accessLink.is_locked,
-    }
-
-    return pack_json_result({"data": {"accessLink": data}})
+    return pack_json_result(data, wrap_for_frontend=False)
 
 
 @router.post(
@@ -147,7 +122,7 @@ def toggle_heuristic(
     notification.send_organization_update(
         project_id, f"information_source_updated:{information_source_id}"
     )
-    return pack_json_result({"data": {"toggleInformationSource": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -161,7 +136,7 @@ def set_information_sources(
 ):
     manager.set_all_information_source_selected(project_id, value)
     notification.send_organization_update(project_id, "information_source_updated:all")
-    return pack_json_result({"data": {"setAllInformationSources": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -193,7 +168,7 @@ def set_payload(
     if task_master_response.ok:
         queue_id = task_master_response.json().get("task_id")
 
-    return pack_json_result({"data": {"createPayload": {"queueId": queue_id}}})
+    return pack_json_result({"queueId": queue_id})
 
 
 @router.delete(
@@ -209,7 +184,7 @@ def delete_heuristic(
     notification.send_organization_update(
         project_id, f"information_source_deleted:{heuristic_id}"
     )
-    return pack_json_result({"data": {"deleteInformationSource": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -222,7 +197,7 @@ def create_heuristic(
     body: CreateHeuristicBody = Body(...),
 ):
     user = auth_manager.get_user_by_info(request.state.info)
-    information_source = manager.create_information_source(
+    info_source = manager.create_information_source(
         project_id,
         user.id,
         body.labeling_task_id,
@@ -232,11 +207,9 @@ def create_heuristic(
         body.type,
     )
     notification.send_organization_update(
-        project_id, f"information_source_created:{str(information_source.id)}"
+        project_id, f"information_source_created:{str(info_source.id)}"
     )
-    return {
-        "data": {"createInformationSource": {"informationSource": information_source}}
-    }
+    return get_silent_success()
 
 
 @router.post(
@@ -261,4 +234,4 @@ def update_heuristic(
     notification.send_organization_update(
         project_id, f"information_source_updated:{heuristic_id}:{user.id}"
     )
-    return {"data": {"updateInformationSource": {"ok": True}}}
+    return get_silent_success()
diff --git a/fast_api/routes/labeling.py b/fast_api/routes/labeling.py
index d1d2bb54..d38ea84b 100644
--- a/fast_api/routes/labeling.py
+++ b/fast_api/routes/labeling.py
@@ -6,17 +6,14 @@
     AddExtractionLabelBody,
     AvailableLinksBody,
     DeleteRecordLabelAssociationBody,
-    GenerateAccessLinkBody,
     HuddleDataBody,
     LinkRouteBody,
-    LockAccessLinkBody,
     RemoveGoldStarBody,
     SetGoldStarBody,
-    StringBody,
     TokenizedRecordBody,
 )
 from submodules.model import enums
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 from controller.labeling_access_link import manager
 from controller.labeling_task_label import manager as label_manager
 from controller.labeling_task import manager as task_manager
@@ -56,7 +53,7 @@ def get_available_links(
     assumed_heuristic_id = body.assumedHeuristicId
 
     if assumed_heuristic_id == manager.DUMMY_LINK_ID:
-        return pack_json_result({"data": {"availableLinks": []}})
+        return pack_json_result([])
     if assumed_heuristic_id:
         is_item = information_source.get(project_id, assumed_heuristic_id)
         if not is_item:
@@ -93,7 +90,7 @@ def get_name(link_type, data_slice_id, heuristic_id):
             if key not in AVAILABLE_LINKS_WHITELIST:
                 obj.pop(key, None)
 
-    return pack_json_result({"data": {"availableLinks": available_links}})
+    return pack_json_result(available_links)
 
 
 @router.post(
@@ -124,14 +121,14 @@ def get_huddle_data(
         "checkedAt": huddle_data.checked_at.isoformat(),
     }
 
-    return pack_json_result({"data": {"requestHuddleData": data}})
+    return pack_json_result(data)
 
 
 @router.post("/tokenized-record")
 def get_tokenized_record(request: Request, body: TokenizedRecordBody = Body(...)):
     record_item = record.get_without_project_id(body.record_id)
     if not record_item:
-        return pack_json_result({"data": {"tokenizeRecord": None}})
+        return pack_json_result(None)
 
     # Delegated here due to record_item dep
     auth_manager.check_project_access(request.state.info, record_item.project_id)
@@ -171,7 +168,7 @@ def get_tokenized_record(request: Request, body: TokenizedRecordBody = Body(...)
         "attributes": attributes,
     }
 
-    return pack_json_result({"data": {"tokenizeRecord": data}})
+    return pack_json_result(data)
 
 
 @router.delete(
@@ -191,7 +188,7 @@ def delete_record_label_association_by_ids(
         project_id, record_id, association_ids, user.id
     )
 
-    return pack_json_result({"data": {"deleteRecordLabelAssociation": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete(
@@ -205,7 +202,7 @@ def delete_record_by_id(
 ):
     record_manager.delete_record(project_id, record_id)
     notification.send_organization_update(project_id, f"record_deleted:{record_id}")
-    return pack_json_result({"data": {"deleteRecord": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -218,87 +215,7 @@ def get_link_locked(
     linkRouteBody: LinkRouteBody = Body(...),
 ):
     is_locked = manager.check_link_locked(project_id, linkRouteBody.link_route)
-    return pack_json_result({"data": {"linkLocked": is_locked}})
-
-
-@router.post(
-    "/{project_id}/generate-access-link",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def generate_access_link(
-    request: Request,
-    project_id: str,
-    generateAccessLinkBody: GenerateAccessLinkBody = Body(...),
-):
-
-    user = auth_manager.get_user_by_info(request.state.info)
-
-    try:
-        link_type_parsed = enums.LinkTypes[generateAccessLinkBody.type.upper()]
-    except KeyError:
-        raise ValueError(f"Invalid LinkTypes: {generateAccessLinkBody.type}")
-
-    if link_type_parsed == enums.LinkTypes.HEURISTIC:
-        link = manager.generate_heuristic_access_link(
-            project_id, user.id, generateAccessLinkBody.id
-        )
-    elif link_type_parsed == enums.LinkTypes.DATA_SLICE:
-        print("not yet supported")
-    notification.send_organization_update(
-        project_id, f"access_link_created:{str(link.id)}"
-    )
-
-    data = {
-        "link": {
-            "id": str(link.id),
-            "link": link.link,
-            "isLocked": link.is_locked,
-        }
-    }
-
-    return pack_json_result({"data": {"generateAccessLink": data}})
-
-
-@router.delete(
-    "/{project_id}/remove-access-link",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def remove_access_link(
-    request: Request,
-    project_id: str,
-    stringBody: StringBody = Body(...),
-):
-
-    type_id = manager.remove(stringBody.value)
-    notification.send_organization_update(
-        project_id, f"access_link_removed:{stringBody.value}:{type_id}"
-    )
-
-    data = {"ok": True}
-
-    return pack_json_result({"data": {"removeAccessLink": data}})
-
-
-@router.put(
-    "/{project_id}/lock-access-link",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def lock_access_link(
-    request: Request,
-    project_id: str,
-    lockAccessLinkBody: LockAccessLinkBody = Body(...),
-):
-    type_id = manager.change_user_access_to_link_lock(
-        lockAccessLinkBody.link_id, lockAccessLinkBody.lock_state
-    )
-    notification.send_organization_update(
-        project_id,
-        f"access_link_changed:{lockAccessLinkBody.link_id}:{type_id}:{lockAccessLinkBody.lock_state}",
-    )
-
-    data = {"ok": True}
-
-    return pack_json_result({"data": {"lockAccessLink": data}})
+    return pack_json_result(is_locked)
 
 
 @router.post(
@@ -320,7 +237,7 @@ def add_classification_labels_to_record(
     )
 
     notification.send_organization_update(project_id, f"rla_created:{body.record_id}")
-    return pack_json_result({"data": {"addClassificationLabelsToRecord": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -344,7 +261,7 @@ def add_extraction_label_to_record(
         body.source_id,
     )
     notification.send_organization_update(project_id, f"rla_created:{body.record_id}")
-    return pack_json_result({"data": {"addExtractionLabelToRecord": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -353,7 +270,7 @@ def add_extraction_label_to_record(
 )
 def set_gold_star(request: Request, project_id: str, body: SetGoldStarBody = Body(...)):
     notification.send_organization_update(project_id, f"rla_created:{body.record_id}")
-    return pack_json_result({"data": {"setGoldStarAnnotationForTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -368,7 +285,7 @@ def remove_gold_star(
         project_id, user.id, body.record_id, body.labeling_task_id
     )
     notification.send_organization_update(project_id, f"rla_deleted:{body.record_id}")
-    return pack_json_result({"data": {"removeGoldStarAnnotationForTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.get(
@@ -381,7 +298,7 @@ def get_record_label_associations(
     record_id: str,
 ):
     if record_id is None or record_id == "null":
-        return pack_json_result({"data": {"recordByRecordId": None}})
+        return pack_json_result(None)
 
     record = record_manager.get_record(project_id, record_id)
 
@@ -390,7 +307,7 @@ def get_record_label_associations(
     first_name = names.get("first", "")
     last_name = names.get("last", "")
 
-    edges = []
+    record_label_associations = []
     rla = record.record_label_associations
     for r in rla:
 
@@ -454,33 +371,31 @@ def get_record_label_associations(
                     }
 
                 labelingTaskLabelDict["labeling_task"]["attribute"] = attributeDict
-        edges.append(
+        record_label_associations.append(
             {
-                "node": {
-                    "id": str(r.id),
-                    "recordId": str(r.record_id),
-                    "labelingTaskLabelId": str(r.labeling_task_label_id),
-                    "source_id": getattr(r, "source_id", None),
-                    "source_type": r.source_type,
-                    "return_type": r.return_type,
-                    "confidence": getattr(r, "confidence", None),
-                    "created_at": r.created_at,
-                    "created_by": str(r.created_by),
-                    "token_start_idx": token_start_idx,
-                    "token_end_idx": token_end_idx,
-                    "is_gold_star": getattr(r, "is_gold_star", None),
-                    "user": {
-                        "id": str(user_id),
-                        "firstName": first_name,
-                        "lastName": last_name,
-                        "mail": mail,
-                    },
-                    "information_source": informationSourceDict,
-                    "labeling_task_label": labelingTaskLabelDict,
-                }
+                "id": str(r.id),
+                "recordId": str(r.record_id),
+                "labelingTaskLabelId": str(r.labeling_task_label_id),
+                "source_id": getattr(r, "source_id", None),
+                "source_type": r.source_type,
+                "return_type": r.return_type,
+                "confidence": getattr(r, "confidence", None),
+                "created_at": r.created_at,
+                "created_by": str(r.created_by),
+                "token_start_idx": token_start_idx,
+                "token_end_idx": token_end_idx,
+                "is_gold_star": getattr(r, "is_gold_star", None),
+                "user": {
+                    "id": str(user_id),
+                    "firstName": first_name,
+                    "lastName": last_name,
+                    "mail": mail,
+                },
+                "information_source": informationSourceDict,
+                "labeling_task_label": labelingTaskLabelDict,
             }
         )
 
-    data = {"id": str(record.id), "recordLabelAssociations": {"edges": edges}}
+    data = {"id": str(record.id), "recordLabelAssociations": record_label_associations}
 
-    return pack_json_result({"data": {"recordByRecordId": data}})
+    return pack_json_result(data)
diff --git a/fast_api/routes/labeling_tasks.py b/fast_api/routes/labeling_tasks.py
index 2d505d72..bd2e1aa8 100644
--- a/fast_api/routes/labeling_tasks.py
+++ b/fast_api/routes/labeling_tasks.py
@@ -13,7 +13,7 @@
 from controller.auth import manager as auth_manager
 from controller.labeling_task import manager as labeling_manager
 from controller.labeling_task_label import manager as label_manager
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import get_silent_success
 from util import notification
 
 
@@ -38,7 +38,7 @@ def update_labeling_task(project_id: str, body: UpdateLabelingTaskBody = Body(..
         f"labeling_task_updated:{body.labeling_task_id}:{body.labeling_task_type}",
     )
 
-    return pack_json_result({"data": {"updateLabelingTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete(
@@ -53,7 +53,7 @@ def delete_labeling_task(project_id: str, body: StringBody = Body(...)):
         project_id, f"labeling_task_deleted:{labeling_task_id}"
     )
 
-    return pack_json_result({"data": {"deleteLabelingTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -74,7 +74,7 @@ def create_labeling_task(
         project_id, f"labeling_task_created:{str(item.id)}"
     )
 
-    return pack_json_result({"data": {"createLabelingTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete(
@@ -90,7 +90,7 @@ def delete_label(project_id: str, body: StringBody = Body(...)):
         project_id, f"label_deleted:{label_id}:labeling_task:{labeling_task_id}"
     )
 
-    return pack_json_result({"data": {"deleteLabel": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -109,14 +109,13 @@ def create_label(
     if project_id:
         auth_manager.check_project_access(request.state.info, project_id)
 
-    user = auth_manager.get_user_by_info(request.state.info)
     label = label_manager.create_label(
         project_id, label_name, labeling_task_id, label_color
     )
     notification.send_organization_update(
         project_id, f"label_created:{label.id}:labeling_task:{labeling_task_id}"
     )
-    return pack_json_result({"data": {"createLabel": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.put(
@@ -127,7 +126,7 @@ def update_label_color(project_id: str, body: UpdateLabelColorBody = Body(...)):
     label_manager.update_label_color(
         project_id, body.labeling_task_label_id, body.label_color
     )
-    return pack_json_result({"data": {"updateLabelColor": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.put(
@@ -138,7 +137,7 @@ def update_label_hotkey(project_id: str, body: UpdateLabelHotkeyBody = Body(...)
     label_manager.update_label_hotkey(
         project_id, body.labeling_task_label_id, body.label_hotkey
     )
-    return pack_json_result({"data": {"updateLabelHotkey": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -150,7 +149,7 @@ def handle_label_rename_warnings(
     body: WarningDataBody = Body(...),
 ):
     label_manager.handle_label_rename_warning(project_id, body.warning_data)
-    return pack_json_result({"data": {"handleLabelRenameWarnings": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.put(
@@ -162,4 +161,4 @@ def update_label_name(
     body: UpdateLabelNameBody = Body(...),
 ):
     label_manager.update_label_name(project_id, body.label_id, body.new_name)
-    return pack_json_result({"data": {"updateLabelName": {"ok": True}}})
+    return get_silent_success()
diff --git a/fast_api/routes/lookup_lists.py b/fast_api/routes/lookup_lists.py
index 209dbc43..4427e1ff 100644
--- a/fast_api/routes/lookup_lists.py
+++ b/fast_api/routes/lookup_lists.py
@@ -12,6 +12,7 @@
 from controller.auth import manager as auth_manager
 from util import notification as prj_notification
 from controller.auth.manager import get_user_by_info
+from fast_api.routes.client_response import pack_json_result, get_silent_success
 
 router = APIRouter()
 
@@ -43,7 +44,7 @@ def get_lookup_lists_by_project_id(project_id: str):
             }
         )
 
-    return {"data": {"knowledgeBasesByProjectId": term_data}}
+    return pack_json_result(term_data)
 
 
 @router.get(
@@ -55,8 +56,8 @@ def get_lookup_lists_by_lookup_list_id(
     lookup_list_id: str,
 ):
     data = base_manager.get_knowledge_base(project_id, lookup_list_id)
-    data_dict = sql_alchemy_to_dict(data, column_whitelist=LOOKUP_LIST_WHITELIST)
-    return {"data": {"knowledgeBaseByKnowledgeBaseId": data_dict}}
+    data = sql_alchemy_to_dict(data, column_whitelist=LOOKUP_LIST_WHITELIST)
+    return pack_json_result(data)
 
 
 @router.get(
@@ -68,8 +69,8 @@ def get_terms_by_lookup_list_id(
     lookup_list_id: str,
 ):
     data = terms_manager.get_terms_by_knowledge_base(project_id, lookup_list_id)
-    data_dict = sql_alchemy_to_dict(data, column_whitelist=LOOKUP_LIST_TERM_WHITELIST)
-    return {"data": {"termsByKnowledgeBaseId": data_dict}}
+    data = sql_alchemy_to_dict(data, column_whitelist=LOOKUP_LIST_TERM_WHITELIST)
+    return pack_json_result(data)
 
 
 @router.get(
@@ -80,13 +81,8 @@ def get_export_lookup_list(
     project_id: str,
     lookup_list_id: str,
 ):
-    return {
-        "data": {
-            "exportKnowledgeBase": transfer_manager.export_knowledge_base(
-                project_id, lookup_list_id
-            )
-        }
-    }
+    data = transfer_manager.export_knowledge_base(project_id, lookup_list_id)
+    return pack_json_result(data)
 
 
 @router.post(
@@ -103,15 +99,13 @@ def create_knowledge_base(
     )
 
     data = {
-        "knowledgeBase": {
-            "id": str(knowledge_base.id),
-            "name": knowledge_base.name,
-            "description": knowledge_base.description,
-            "termCount": len(knowledge_base.terms),
-        }
+        "id": str(knowledge_base.id),
+        "name": knowledge_base.name,
+        "description": knowledge_base.description,
+        "termCount": len(knowledge_base.terms),
     }
 
-    return {"data": {"createKnowledgeBase": data}}
+    return pack_json_result(data)
 
 
 @router.delete(
@@ -128,7 +122,7 @@ def delete_knowledge_base(
         project_id, f"knowledge_base_deleted:{str(knowledge_base_id)}"
     )
 
-    return {"data": {"deleteKnowledgeBase": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.put(
@@ -155,7 +149,7 @@ def update_knowledge_base(
         f"knowledge_base_updated:{str(updateKnowledgeBaseBody.knowledge_base_id)}",
     )
 
-    return {"data": {"updateKnowledgeBase": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.post(
@@ -182,7 +176,7 @@ def add_term_to_knowledge_base(
         f"knowledge_base_term_updated:{str(termBody.knowledge_base_id)}",
     )
 
-    return {"data": {"addTermToKnowledgeBase": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.delete(
@@ -197,7 +191,7 @@ def delete_term(project_id: str, term_id: str):
         project_id, f"knowledge_base_term_updated:{str(base.id)}"
     )
 
-    return {"data": {"deleteTerm": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.put(
@@ -206,7 +200,7 @@ def delete_term(project_id: str, term_id: str):
 )
 def blacklist_term(project_id: str, term_id: str):
     terms_manager.blacklist_term(term_id)
-    return {"data": {"blacklistTerm": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.post(
@@ -229,7 +223,7 @@ def paste_knowledge_terms(
         f"knowledge_base_term_updated:{str(pasteBody.knowledge_base_id)}",
     )
 
-    return {"data": {"pasteKnowledgeTerms": {"ok": True}}}
+    return get_silent_success()
 
 
 @router.put(
@@ -257,4 +251,4 @@ def update_term(
         str(project_id), f"knowledge_base_term_updated:{str(base.id)}"
     )
 
-    return {"data": {"updateTerm": {"ok": True}}}
+    return get_silent_success()
diff --git a/fast_api/routes/misc.py b/fast_api/routes/misc.py
index b9850ff3..f7f2905a 100644
--- a/fast_api/routes/misc.py
+++ b/fast_api/routes/misc.py
@@ -7,7 +7,11 @@
     CreateCustomerButton,
     UpdateCustomerButton,
 )
-from fast_api.routes.client_response import pack_json_result, SILENT_SUCCESS_RESPONSE
+from fast_api.routes.client_response import (
+    pack_json_result,
+    get_silent_success,
+    GENERIC_FAILURE_RESPONSE,
+)
 from typing import Dict, Optional
 from controller.auth import manager as auth
 from controller.misc import manager
@@ -30,19 +34,19 @@
 @router.get("/is-admin")
 def get_is_admin(request: Request) -> Dict:
     data = auth.check_is_admin(request)
-    return pack_json_result({"data": {"isAdmin": data}})
+    return pack_json_result(data)
 
 
 @router.get("/version-overview")
 def get_version_overview(request: Request) -> Dict:
     data = manager.get_version_overview()
-    return pack_json_result({"data": {"versionOverview": data}})
+    return pack_json_result(data)
 
 
 @router.get("/has-updates")
 def has_updates(request: Request) -> Dict:
     data = manager.has_updates()
-    return pack_json_result({"data": {"hasUpdates": data}})
+    return pack_json_result(data)
 
 
 @router.delete("/model-provider-delete-model")
@@ -53,7 +57,7 @@ def model_provider_delete_model(
         auth.check_admin_access(request.state.info)
     model_provider_manager.model_provider_delete_model(body.model_name)
 
-    return pack_json_result({"data": {"modelProviderDeleteModel": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post("/model-provider-download-model")
@@ -64,7 +68,7 @@ def model_provider_download_model(
         auth.check_admin_access(request.state.info)
     model_provider_manager.model_provider_download_model(body.model_name)
 
-    return pack_json_result({"data": {"modelProviderDownloadModel": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.get("/all-tasks")
@@ -84,7 +88,7 @@ def delete_from_task_queue_db(
 ):
     auth.check_admin_access(request.state.info)
     task_master_manager.delete_task(org_id, task_id)
-    return SILENT_SUCCESS_RESPONSE
+    return get_silent_success()
 
 
 @router.post("/cancel-task")
@@ -100,7 +104,7 @@ def cancel_task(
 
     task_entity = task_queue_bo.get(task_id)
     if not task_entity:
-        return pack_json_result({"data": {"cancelTask": {"ok": False}}})
+        return GENERIC_FAILURE_RESPONSE
     if task_entity and (
         task_entity.is_active or task_type == enums.TaskType.PARSE_MARKDOWN_FILE.value
     ):
@@ -126,14 +130,14 @@ def cancel_task(
             raise ValueError(f"{task_type} is no valid task type")
 
     task_queue_bo.delete_by_task_id(task_id, True)
-    return pack_json_result({"data": {"cancelTask": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post("/cancel-all-running-tasks")
 def cancel_all_running_tasks(request: Request):
     auth.check_admin_access(request.state.info)
     controller_manager.cancel_all_running_tasks()
-    return pack_json_result({"data": {"cancelAllRunningTasks": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post("/pause-task-queue")
@@ -146,7 +150,7 @@ def pause_task_queue(request: Request, task_queue_pause: bool):
             task_queue_pause = task_queue_pause_response.json()["task_queue_pause"]
         except Exception:
             task_queue_pause = False
-    return pack_json_result({"taskQueuePause": task_queue_pause})
+    return pack_json_result(task_queue_pause)
 
 
 @router.get("/pause-task-queue")
@@ -159,7 +163,7 @@ def get_task_queue_pause(request: Request):
             task_queue_pause = task_queue_pause_response.json()["task_queue_pause"]
         except Exception:
             task_queue_pause = False
-    return pack_json_result({"taskQueuePause": task_queue_pause})
+    return pack_json_result(task_queue_pause)
 
 
 # this endpoint is meant to be used by the frontend to get the customer buttons for the current user
@@ -227,7 +231,7 @@ def delete_customer_buttons(button_id: str, request: Request):
     # all (only for admins on admin page!)
     auth.check_admin_access(request.state.info)
     customer_button_db_go.delete(button_id)
-    return SILENT_SUCCESS_RESPONSE
+    return get_silent_success()
 
 
 @router.post("/update-customer-button/{button_id}")
diff --git a/fast_api/routes/notification.py b/fast_api/routes/notification.py
index 688612d8..d80d3839 100644
--- a/fast_api/routes/notification.py
+++ b/fast_api/routes/notification.py
@@ -18,9 +18,9 @@
 def get_notification(request: Request):
     info = request.state.info
     user_id = auth.get_user_by_info(info).id
-    data = manager.get_notification(user_id)
-    data_dict = sql_alchemy_to_dict(data, column_whitelist=NOTIFICATION_WHITELIST)
-    return pack_json_result({"data": {"notificationsByUserId": data_dict}})
+    notification = manager.get_notification(user_id)
+    data = sql_alchemy_to_dict(notification, column_whitelist=NOTIFICATION_WHITELIST)
+    return pack_json_result(data)
 
 
 @router.post("/notifications")
@@ -49,4 +49,4 @@ def get_notifications(
         notification["page"] = notification_data["page"]
         notification["title"] = notification_data["title"]
 
-    return pack_json_result({"data": {"notifications": data}})
+    return pack_json_result(data)
diff --git a/fast_api/routes/organization.py b/fast_api/routes/organization.py
index be27a4b1..79aa3f77 100644
--- a/fast_api/routes/organization.py
+++ b/fast_api/routes/organization.py
@@ -16,7 +16,7 @@
 )
 from controller.auth import manager as auth_manager
 from controller.auth.kratos import (
-    resolve_user_name_and_email_by_id,
+    resolve_user_name_by_id,
 )
 from controller.organization import manager
 from controller.admin_message import manager as admin_message_manager
@@ -40,67 +40,71 @@
     "scheduled_date",
 }
 
+USER_INFO_WHITELIST = {
+    "id",
+    "organization_id",
+    "role",
+    "language_display",
+    "email",
+}
+USER_INFO_RENAME_MAP = {"email": "mail"}
+ALL_ORGANIZATIONS_WHITELIST = {
+    "id",
+    "name",
+    "created_at",
+    "started_at",
+    "is_paying",
+    "max_rows",
+    "max_cols",
+    "max_char_count",
+    "log_admin_requests",
+    "conversation_lifespan_days",
+    "file_lifespan_days",
+}
 
+
+# in use refinery-ui (07.01.25)
 @router.get("")
 def get_organization(request: Request):
     user = auth_manager.get_user_by_info(request.state.info)
-    organization = manager.get_organization_by_id(user.organization_id)
 
-    return pack_json_result({"data": {"userOrganization": organization}})
+    return pack_json_result(manager.get_organization_by_id(user.organization_id))
 
 
+# in use refinery-ui (07.01.25)
 @router.get("/overview-stats")
 def get_overview_stats(request: Request):
     org_id = str(auth_manager.get_user_by_info(request.state.info).organization_id)
-    data = manager.get_overview_stats(org_id)
 
-    return {"data": {"overviewStats": data}}
+    return pack_json_result(manager.get_overview_stats(org_id), wrap_for_frontend=False)
 
 
+# in use refinery-ui (07.01.25)
 @router.get("/user-info")
 def get_user_info(request: Request):
     user = auth_manager.get_user_by_info(request.state.info)
-    data = manager.get_user_info(user)
-    return {"data": {"userInfo": data}}
+    return pack_json_result(manager.get_user_info(user), wrap_for_frontend=False)
 
 
+# in use cognition-ui & admin dashboard (07.01.25)
 @router.get("/get-user-info-extended")
 def get_user_info_extended(request: Request):
     user = auth_manager.get_user_by_info(request.state.info)
-    name, mail = resolve_user_name_and_email_by_id(user.id)
-
-    data = {
-        "userInfo": {
-            "id": str(user.id),
-            "organizationId": (
-                str(user.organization_id) if user.organization_id else None
-            ),
-            "firstName": name.get("first"),
-            "lastName": name.get("last"),
-            "mail": mail,
-            "role": user.role,
-            "languageDisplay": user.language_display,
-        }
+    name = resolve_user_name_by_id(user.id)
+    user_dict = {
+        **sql_alchemy_to_dict(
+            user,
+            column_whitelist=USER_INFO_WHITELIST,
+            column_rename_map=USER_INFO_RENAME_MAP,
+        ),
+        "first_name": name.get("first"),
+        "last_name": name.get("last"),
     }
 
-    return pack_json_result({"data": data})
-
-
-@router.get("/get-user-info-mini")
-def get_user_info_mini(request: Request):
-    user = auth_manager.get_user_by_info(request.state.info)
-
-    data = {
-        "userInfo": {
-            "id": str(user.id),
-            "organization": {"id": str(user.organization_id)},
-            "role": user.role,
-        }
-    }
-
-    return pack_json_result({"data": data})
+    return pack_json_result(user_dict)
 
 
+# in use admin dashboard (08.01.25)
 @router.get("/org-id-name-map")
 def get_org_id_name_map(request: Request):
     auth_manager.check_admin_access(request.state.info)
@@ -109,13 +113,16 @@ def get_org_id_name_map(request: Request):
     )
 
 
+# in use cognition-ui & refinery-ui (08.01.25)
 @router.get("/all-users")
 def get_all_user(request: Request):
     organization_id = auth_manager.get_user_by_info(request.state.info).organization_id
-    data = manager.get_all_users(organization_id)
-    return {"data": {"allUsers": data}}
+    return pack_json_result(
+        manager.get_all_users(organization_id), wrap_for_frontend=False
+    )
 
 
+# in use cognition-ui & refinery-ui & admin-dashboard (08.01.25)
 @router.get("/all-active-admin-messages")
 def all_active_admin_messages(request: Request, limit: int = 100) -> str:
 
@@ -123,110 +130,94 @@ def all_active_admin_messages(request: Request, limit: int = 100) -> str:
     data_dict = sql_alchemy_to_dict(
         data, column_whitelist=ACTIVE_ADMIN_MESSAGES_WHITELIST
     )
-    return pack_json_result({"data": {"allActiveAdminMessages": data_dict}})
+    return pack_json_result(data_dict)
 
 
+# in use admin-dashboard (08.01.25)
 @router.get("/all-admin-messages")
 def all_admin_messages(request: Request, limit: int = 100) -> str:
     auth_manager.check_admin_access(request.state.info)
     data = admin_message_manager.get_messages(limit, active_only=False)
     data_dict = sql_alchemy_to_dict(data)
-    return pack_json_result({"data": {"allAdminMessages": data_dict}})
+    return pack_json_result(data_dict)
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/create-organization")
 def create_organization(request: Request, body: CreateOrganizationBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
-    organization = organization_manager.create_organization(body.name)
-    return {"data": {"createOrganization": {"organization": organization}}}
+    organization_manager.create_organization(body.name)
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/add-user-to-organization")
 def add_user_to_organization(
     request: Request, body: AddUserToOrganizationBody = Body(...)
 ):
     auth_manager.check_admin_access(request.state.info)
     user_manager.update_organization_of_user(body.organization_name, body.user_mail)
-    return pack_json_result({"data": {"addUserToOrganization": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/remove-user-from-organization")
 def remove_user_from_organization(
     request: Request, body: RemoveUserToOrganizationBody = Body(...)
 ):
     auth_manager.check_admin_access(request.state.info)
     user_manager.remove_organization_from_user(body.user_mail)
-    return pack_json_result({"data": {"removeUserFromOrganization": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/change-organization")
 def change_organization(request: Request, body: ChangeOrganizationBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
     organization_manager.change_organization(body.org_id, json.loads(body.changes))
-    return pack_json_result({"data": {"changeOrganization": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.get("/user-roles")
 def get_user_roles(request: Request):
     auth_manager.check_admin_access(request.state.info)
     data = user_manager.get_user_roles()
-    return {"data": {"userRoles": data}}
+    return pack_json_result(data)
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/change-user-role")
 def change_user_role(request: Request, body: ChangeUserRoleBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
     user_manager.update_user_role(body.user_id, body.role)
-    return {"data": {"changeUserRole": {"ok": True}}}
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.get("/all-organizations")
 def get_all_organizations(request: Request):
     auth_manager.check_admin_access(request.state.info)
     organizations = manager.get_all_organizations()
-
-    edges = []
-
-    for org in organizations:
-        edges.append(
-            {
-                "node": {
-                    "id": str(org.id),
-                    "name": org.name,
-                    "createdAt": (
-                        org.created_at.isoformat()
-                        if org.created_at is not None
-                        else None
-                    ),
-                    "startedAt": (
-                        org.started_at.isoformat()
-                        if org.started_at is not None
-                        else None
-                    ),
-                    "isPaying": org.is_paying,
-                    "userCount": manager.get_user_count(org.id),
-                    "maxRows": org.max_rows,
-                    "maxCols": org.max_cols,
-                    "maxCharCount": org.max_char_count,
-                    "logAdminRequests": org.log_admin_requests,
-                    "conversationLifespanDays": org.conversation_lifespan_days,
-                    "fileLifespanDays": org.file_lifespan_days,
-                }
-            }
-        )
-
-    data = {"edges": edges}
-
-    return pack_json_result({"data": {"allOrganizations": data}})
+    org_dicts = [
+        {
+            **sql_alchemy_to_dict(org, column_whitelist=ALL_ORGANIZATIONS_WHITELIST),
+            "userCount": manager.get_user_count(org.id),
+        }
+        for org in organizations
+    ]
+    return pack_json_result(org_dicts)
 
 
+# in use admin-dashboard (08.01.25)
 @router.delete("/delete-organization")
 def delete_organization(request: Request, body: DeleteOrganizationBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
     organization_manager.delete_organization(body.name)
-    return pack_json_result({"data": {"deleteOrganization": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/create-admin-message")
 def create_admin_message(request: Request, body: CreateAdminMessageBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
@@ -235,9 +226,10 @@ def create_admin_message(request: Request, body: CreateAdminMessageBody = Body(.
         body.text, body.level, body.archive_date, body.scheduled_date, user_id
     )
     notification.send_global_update_for_all_organizations("admin_message")
-    return pack_json_result({"data": {"createAdminMessage": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.delete("/archive-admin-message")
 def archive_admin_message(
     request: Request,
@@ -249,15 +241,17 @@ def archive_admin_message(
         body.message_id, user_id, body.archived_reason
     )
     notification.send_global_update_for_all_organizations("admin_message")
-    return pack_json_result({"data": {"archiveAdminMessage": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use cognition-ui (08.01.25)
 @router.post("/set-language-display")
 def set_language_display(request: Request, body: UserLanguageDisplay = Body(...)):
     user_manager.update_user_language_display(body.user_id, body.language_display)
-    return pack_json_result({"data": {"changeUserLanguageDisplay": {"ok": True}}})
+    return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/mapped-sorted-paginated-users")
 def get_mapped_sorted_paginated_users(
     request: Request, body: MappedSortedPaginatedUsers = Body(...)
@@ -293,6 +287,7 @@ def get_mapped_sorted_paginated_users(
     )
 
 
+# in use admin-dashboard (08.01.25)
 @router.delete("/delete-user")
 def delete_user(request: Request, body: DeleteUserBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
@@ -300,6 +295,7 @@ def delete_user(request: Request, body: DeleteUserBody = Body(...)):
     return get_silent_success()
 
 
+# in use admin-dashboard (08.01.25)
 @router.post("/missing-users-interaction")
 def get_missing_users_interaction(request: Request, body: MissingUsersBody = Body(...)):
     auth_manager.check_admin_access(request.state.info)
@@ -307,6 +303,7 @@ def get_missing_users_interaction(request: Request, body: MissingUsersBody = Bod
     return pack_json_result(data, wrap_for_frontend=False)
 
 
+# in use admin-dashboard (08.01.25)
 @router.get("/user-to-organization")
 def get_user_to_organization(request: Request):
     auth_manager.check_admin_access(request.state.info)
diff --git a/fast_api/routes/project.py b/fast_api/routes/project.py
index 3b0425ce..fc7fac5f 100644
--- a/fast_api/routes/project.py
+++ b/fast_api/routes/project.py
@@ -1,6 +1,4 @@
-import json
 from typing import Optional
-
 from fast_api.models import (
     CreateProjectBody,
     CreateSampleProjectBody,
@@ -10,29 +8,22 @@
     UploadCredentialsAndIdBody,
 )
 from fastapi import APIRouter, Body, Depends, Request
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import get_silent_success, pack_json_result
 from typing import Dict
 from controller.auth import manager as auth_manager
-from controller.attribute import manager as attr_manager
 from controller.upload_task import manager as upload_task_manager
-from submodules.model.business_objects import information_source, labeling_task
+from submodules.model.business_objects import labeling_task
 from submodules.model import enums
-from submodules.model.business_objects.embedding import get_all_embeddings_by_project_id
 from submodules.model.business_objects.project import get_project_by_project_id_sql
-from submodules.model.business_objects.labeling_task import (
-    get_labeling_tasks_by_project_id_full,
-)
 from controller.project import manager
 from controller.model_provider import manager as model_manager
 from controller.transfer import manager as transfer_manager
 from submodules.model.util import (
-    pack_edges_node,
     sql_alchemy_to_dict,
     to_frontend_obj_raw,
 )
 from util import notification
 from submodules.model.business_objects import notification as notification_model
-
 from submodules.model.business_objects import tokenization, task_queue
 
 router = APIRouter()
@@ -68,7 +59,7 @@ def get_project_by_project_id(
     project_id: str,
 ) -> Dict:
     data = get_project_by_project_id_sql(project_id)
-    return pack_json_result({"data": {"projectByProjectId": data}})
+    return pack_json_result(data)
 
 
 @router.get("/all-projects")
@@ -76,8 +67,7 @@ def get_all_projects(request: Request) -> Dict:
     projects = manager.get_all_projects_by_user(
         auth_manager.get_organization_id_by_info(request.state.info)
     )
-    projects_packed = pack_edges_node(projects, "allProjects")
-    return pack_json_result(projects_packed)
+    return pack_json_result(projects)
 
 
 @router.get("/all-projects-mini")
@@ -86,25 +76,17 @@ def get_all_projects_mini(request: Request) -> Dict:
         auth_manager.get_organization_id_by_info(request.state.info)
     )
 
-    edges = []
-
-    for project in projects:
-        edges.append(
-            {
-                "node": {
-                    "id": str(project.get("id", None)),
-                    "name": str(project.get("name", None)),
-                    "description": str(project.get("description", None)),
-                    "status": str(project.get("status", None)),
-                }
-            }
-        )
-
-    data = {
-        "edges": edges,
-    }
+    project_extended = [
+        {
+            "id": str(project.get("id")),
+            "name": str(project.get("name")),
+            "description": str(project.get("description")),
+            "status": str(project.get("status")),
+        }
+        for project in projects
+    ]
 
-    return pack_json_result({"data": {"allProjects": data}})
+    return pack_json_result(project_extended)
 
 
 @router.get(
@@ -116,15 +98,9 @@ def general_project_stats(
     labeling_task_id: Optional[str] = None,
     slice_id: Optional[str] = None,
 ) -> Dict:
-
+    data = manager.get_general_project_stats(project_id, labeling_task_id, slice_id)
     return pack_json_result(
-        {
-            "data": {
-                "generalProjectStats": manager.get_general_project_stats(
-                    project_id, labeling_task_id, slice_id
-                )
-            }
-        },
+        data,
         wrap_for_frontend=False,  # not wrapped as the prepared results in snake_case are still the expected form the frontend
     )
 
@@ -138,14 +114,9 @@ def label_distribution(
     labeling_task_id: Optional[str] = None,
     slice_id: Optional[str] = None,
 ) -> str:
+    data = manager.get_label_distribution(project_id, labeling_task_id, slice_id)
     return pack_json_result(
-        {
-            "data": {
-                "labelDistribution": manager.get_label_distribution(
-                    project_id, labeling_task_id, slice_id
-                )
-            }
-        },
+        data,
         wrap_for_frontend=False,  # not wrapped as the prepared results in snake_case are still the expected form the frontend
     )
 
@@ -172,9 +143,7 @@ def project_tokenization(project_id: str) -> str:
             tokenization.get_record_tokenization_task(project_id),
             column_whitelist=PROJECT_TOKENIZATION_WHITELIST,
         )
-    return pack_json_result(
-        {"data": {"projectTokenization": data}},
-    )
+    return pack_json_result(data)
 
 
 @router.get(
@@ -182,99 +151,7 @@ def project_tokenization(project_id: str) -> str:
     dependencies=[Depends(auth_manager.check_project_access_dep)],
 )
 def labeling_tasks_by_project_id(project_id: str) -> str:
-    return pack_json_result(
-        {
-            "data": {
-                "projectByProjectId": sql_alchemy_to_dict(
-                    get_labeling_tasks_by_project_id_full(project_id)
-                )
-            }
-        },
-    )
-
-
-@router.get(
-    "/{project_id}/labeling-tasks-by-project-id-with-embeddings",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def labeling_tasks_by_project_id_with_embeddings(
-    project_id: str, only_on_attribute: bool = False
-) -> str:
-    embeddings = get_all_embeddings_by_project_id(project_id)
-
-    embeddings_edges = []
-    for embedding in embeddings:
-        if (
-            only_on_attribute
-            and embedding.type != enums.EmbeddingType.ON_ATTRIBUTE.value
-        ):
-            continue
-        attribute = attr_manager.get_attribute(project_id, embedding.attribute_id)
-        embeddings_edges.append(
-            {
-                "node": {
-                    "id": str(embedding.id),
-                    "name": embedding.name,
-                    "state": embedding.state,
-                    "attribute": {"dataType": attribute.data_type},
-                }
-            }
-        )
-
-    labeling_tasks_all = labeling_task.get_all(project_id)
-
-    labeling_tasks_edges = []
-
-    for labeling_task_item in labeling_tasks_all:
-        information_sources_ids = information_source.get_all_ids_by_labeling_task_id(
-            project_id, labeling_task_item.id
-        )
-
-        information_sources = []
-        for information_source_id in information_sources_ids:
-            is_val = information_source.get(project_id, information_source_id)
-            information_sources.append(is_val)
-
-        information_sources_edges = []
-        for information_source_item in information_sources:
-            last_payload = information_source.get_last_payload(
-                project_id, information_source_item.id
-            )
-            lastPayload = {}
-            if last_payload is not None:
-                lastPayload = {"state": last_payload.state}
-            information_sources_edges.append(
-                {
-                    "node": {
-                        "id": str(information_source_item.id),
-                        "name": information_source_item.name,
-                        "description": information_source_item.description,
-                        "type": information_source_item.type,
-                        "lastPayload": lastPayload,
-                    }
-                }
-            )
-
-        labeling_tasks_edges.append(
-            {
-                "node": {
-                    "id": str(labeling_task_item.id),
-                    "name": labeling_task_item.name,
-                    "taskType": labeling_task_item.task_type,
-                    "informationSources": {"edges": information_sources_edges},
-                }
-            }
-        )
-
-    data = {
-        "data": {
-            "projectByProjectId": {
-                "embeddings": {"edges": embeddings_edges},
-                "labelingTasks": {"edges": labeling_tasks_edges},
-            }
-        }
-    }
-
+    data = labeling_task.get_labeling_tasks_by_project_id_full(project_id)
     return pack_json_result(data)
 
 
@@ -284,14 +161,13 @@ def labeling_tasks_by_project_id_with_embeddings(
 )
 def record_export_by_project_id(project_id: str) -> str:
     data = manager.get_project_with_labeling_tasks_info_attributes(project_id)
-    data_packed = pack_edges_node(data, "projectByProjectId")
-    return pack_json_result(data_packed)
+    return pack_json_result(data)
 
 
 @router.get("/model-provider-info")
 def get_model_provider_info(request: Request) -> Dict:
     data = model_manager.get_model_provider_info()
-    return pack_json_result({"data": {"modelProviderInfo": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -304,7 +180,7 @@ def last_export_credentials(
 ) -> Dict:
 
     data = transfer_manager.last_project_export_credentials(project_id)
-    return pack_json_result({"data": {"lastProjectExportCredentials": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -326,7 +202,7 @@ def upload_credentials_and_id(
         upload_credentials.upload_type,
         upload_credentials.key,
     )
-    return pack_json_result({"data": {"uploadCredentialsAndId": json.dumps(data)}})
+    return pack_json_result(data, wrap_for_frontend=False)
 
 
 @router.get(
@@ -342,9 +218,7 @@ def upload_task_by_id(
         upload_task_id = upload_task_id.split("/")[-1]
     data = upload_task_manager.get_upload_task(project_id, upload_task_id)
     data_dict = to_frontend_obj_raw(sql_alchemy_to_dict(data))
-    return pack_json_result(
-        {"data": {"uploadTaskById": data_dict}}, wrap_for_frontend=False
-    )
+    return pack_json_result(data_dict, wrap_for_frontend=False)
 
 
 @router.post(
@@ -363,7 +237,7 @@ def update_project_name_description(
     )
     # one for the specific project so it's updated
     notification.send_organization_update(project_id, f"project_update:{project_id}")
-    return pack_json_result({"data": {"updateProjectNameDescription": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.delete(
@@ -383,7 +257,7 @@ def delete_project(request: Request, project_id: str):
     notification.send_organization_update(
         project_id, f"project_deleted:{project_id}:{user.id}", True, organization_id
     )
-    return pack_json_result({"data": {"deleteProject": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post("/create-project")
@@ -407,7 +281,7 @@ def create_project(
         }
     }
 
-    return pack_json_result({"data": {"createProject": data}})
+    return pack_json_result(data)
 
 
 @router.put(
@@ -419,7 +293,7 @@ def update_project_tokenizer(
     body: UpdateProjectTokenizerBody = Body(...),
 ):
     manager.update_project(project_id, tokenizer=body.tokenizer)
-    return pack_json_result({"data": {"updateProjectTokenizer": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.put(
@@ -431,7 +305,7 @@ def update_project_status(
     body: UpdateProjectStatusBody = Body(...),
 ):
     manager.update_project(project_id, status=body.new_status)
-    return pack_json_result({"data": {"updateProjectStatus": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post("/create-sample-project")
@@ -446,12 +320,9 @@ def create_sample_project(
     )
 
     data = {
-        "ok": True,
-        "project": {
-            "id": str(project.id),
-            "name": project.name,
-            "description": project.description,
-        },
+        "id": str(project.id),
+        "name": project.name,
+        "description": project.description,
     }
 
-    return pack_json_result({"data": {"createSampleProject": data}})
+    return pack_json_result(data)
diff --git a/fast_api/routes/project_setting.py b/fast_api/routes/project_setting.py
index 78071446..1d7b5144 100644
--- a/fast_api/routes/project_setting.py
+++ b/fast_api/routes/project_setting.py
@@ -1,29 +1,27 @@
 from fast_api.models import (
     CalculateUserAttributeAllRecordsBody,
-    CreateLabelsBody,
     CreateNewAttributeBody,
-    CreateTaskAndLabelsBody,
     PrepareProjectExportBody,
     PrepareRecordExportBody,
     UpdateAttributeBody,
 )
 from fastapi import APIRouter, Body, Depends, Request
 from typing import Dict
-
-from fastapi.responses import JSONResponse
 from controller.auth import manager as auth_manager
 from controller.transfer import manager as transfer_manager
 from controller.attribute import manager as attribute_manager
 from controller.labeling_task_label import manager as label_manager
-from controller.labeling_task import manager as task_manager
 from controller.project import manager as project_manager
 from controller.record import manager as record_manager
 from controller.task_master import manager as task_master_manager
 from controller.task_queue import manager as task_queue_manager
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import (
+    get_custom_response,
+    get_silent_success,
+    pack_json_result,
+)
 from submodules.model.enums import TaskType
 from submodules.model.util import sql_alchemy_to_dict
-from util import notification
 import traceback
 import json
 
@@ -57,7 +55,7 @@ def get_queued_tasks(
 ) -> Dict:
     data = task_queue_manager.get_all_waiting_by_type(project_id, task_type)
     data_dict = sql_alchemy_to_dict(data, column_whitelist=QUEUED_TASKS_WHITELIST)
-    return pack_json_result({"data": {"queuedTasks": data_dict}})
+    return pack_json_result(data_dict)
 
 
 @router.get(
@@ -72,7 +70,7 @@ def get_attribute_by_attribute_id(
         attribute_manager.get_attribute(project_id, attribute_id),
         column_whitelist=ATTRIBUTE_WHITELIST,
     )
-    return pack_json_result({"data": {"attributeByAttributeId": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -85,7 +83,7 @@ def check_rename_label(
     new_name: str,
 ):
     data = label_manager.check_rename_label(project_id, label_id, new_name)
-    return pack_json_result({"data": {"checkRenameLabel": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -98,7 +96,7 @@ def get_last_record_export_credentials(
 ):
     user_id = auth_manager.get_user_id_by_info(request.state.info)
     data = transfer_manager.last_record_export_credentials(project_id, user_id)
-    return pack_json_result({"data": {"lastRecordExportCredentials": data}})
+    return pack_json_result(data)
 
 
 @router.post(
@@ -112,10 +110,7 @@ def prepare_record_export(
         export_options = json.loads(body.export_options)
         key = body.key
     except json.JSONDecodeError:
-        return JSONResponse(
-            status_code=400,
-            content={"message": "Invalid JSON"},
-        )
+        return pack_json_result({"prepared": False, "message": "Invalid JSON"})
 
     user_id = auth_manager.get_user_id_by_info(request.state.info)
 
@@ -123,9 +118,11 @@ def prepare_record_export(
         transfer_manager.prepare_record_export(project_id, user_id, export_options, key)
     except Exception as e:
         print(traceback.format_exc(), flush=True)
-        return str(e)
+        return pack_json_result({"prepared": False, "message": e})
 
-    return pack_json_result({"data": {"prepareRecordExport": ""}})
+    return pack_json_result(
+        {"prepared": True, "message": "Export prepared successfully"}
+    )
 
 
 @router.get(
@@ -137,7 +134,7 @@ def get_record_by_record_id(
     record_id: str,
 ):
     if record_id is None or record_id == "null":
-        return pack_json_result({"data": {"recordByRecordId": None}})
+        return pack_json_result(None)
 
     record = record_manager.get_record(project_id, record_id)
 
@@ -148,7 +145,7 @@ def get_record_by_record_id(
         "category": record.category,
     }
 
-    return pack_json_result({"data": {"recordByRecordId": data}})
+    return pack_json_result(data)
 
 
 @router.get(
@@ -159,7 +156,7 @@ def get_project_size(project_id: str):
     data = project_manager.get_project_size(project_id)
     final_data = [
         {
-            "byteSize": key.byte_size,
+            "byteSize": str(key.byte_size),
             "byteReadable": key.byte_readable,
             "table": key.table,
             "order": key.order,
@@ -168,30 +165,7 @@ def get_project_size(project_id: str):
         }
         for key in data
     ]
-    return {"data": {"projectSize": final_data}}
-
-
-@router.post(
-    "/{project_id}/create-labels",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def create_labels(
-    request: Request,
-    project_id: str,
-    body: CreateLabelsBody = Body(...),
-):
-    labeling_task_id = body.labelingTaskId
-    labels = body.labels
-
-    if project_id:
-        auth_manager.check_project_access(request.state.info, project_id)
-
-    created_labels = label_manager.create_labels(project_id, labeling_task_id, labels)
-    for label in created_labels:
-        notification.send_organization_update(
-            project_id, f"label_created:{label.id}:labeling_task:{labeling_task_id}"
-        )
-    return pack_json_result({"data": {"createLabels": ""}})
+    return pack_json_result(final_data)
 
 
 @router.post(
@@ -206,9 +180,7 @@ def create_new_attribute(
     attribute = attribute_manager.create_user_attribute(
         project_id, body.name, body.data_type
     )
-    return pack_json_result(
-        {"data": {"createUserAttribute": {"attributeId": attribute.id}}}
-    )
+    return pack_json_result({"attributeId": attribute.id})
 
 
 @router.post(
@@ -229,7 +201,7 @@ def update_attribute(
         body.source_code,
         body.visibility,
     )
-    return pack_json_result({"data": {"updateAttribute": {"ok": True}}})
+    return get_silent_success()
 
 
 @router.post(
@@ -255,37 +227,7 @@ def calculate_user_attribute_all_records(
         True,
     )
 
-    return pack_json_result(
-        {"data": {"calculateUserAttributeAllRecords": {"ok": True}}}
-    )
-
-
-@router.post(
-    "/{project_id}/create-task-and-labels",
-    dependencies=[Depends(auth_manager.check_project_access_dep)],
-)
-def create_task_and_labels(
-    request: Request,
-    project_id: str,
-    body: CreateTaskAndLabelsBody = Body(...),
-):
-    item = task_manager.create_labeling_task(
-        project_id,
-        body.labeling_task_name,
-        body.labeling_task_type,
-        body.labeling_task_target_id,
-    )
-
-    if body.labels is not None:
-        label_manager.create_labels(project_id, str(item.id), body.labels)
-
-    notification.send_organization_update(
-        project_id, f"labeling_task_created:{str(item.id)}"
-    )
-
-    return pack_json_result(
-        {"data": {"createTaskAndLabels": {"ok": True, "taskId": item.id}}}
-    )
+    return get_silent_success()
 
 
 @router.post(
@@ -297,7 +239,6 @@ def prepare_project_export(
     project_id: str,
     body: PrepareProjectExportBody = Body(...),
 ):
-    ok = True
     user_id = auth_manager.get_user_by_info(request.state.info).id
 
     try:
@@ -305,8 +246,8 @@ def prepare_project_export(
         transfer_manager.prepare_project_export(
             project_id, user_id, export_options, body.key
         )
-    except Exception:
+    except Exception as e:
         print(traceback.format_exc(), flush=True)
-        ok = False
+        return get_custom_response(400, str(e), "text")
 
-    return pack_json_result({"data": {"prepareProjectExport": {"ok": ok}}})
+    return get_silent_success()
diff --git a/fast_api/routes/record.py b/fast_api/routes/record.py
index b490d6bb..a2a233af 100644
--- a/fast_api/routes/record.py
+++ b/fast_api/routes/record.py
@@ -1,9 +1,14 @@
 from fastapi import APIRouter, Depends, Request, Body
 from controller.record import manager
 from controller.auth import manager as auth_manager
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import (
+    get_custom_response,
+    get_silent_success,
+)
 from fast_api.models import RecordSyncBody
 from util import notification
+from fastapi import status
+import json
 
 router = APIRouter()
 
@@ -21,9 +26,10 @@ def sync_records(
     errors = manager.edit_records(user_id, project_id, record_sync_body.changes)
 
     if errors and len(errors) > 0:
-        return pack_json_result(
-            {"data": {"editRecords": {"ok": False, "errors": errors}}}
+        return get_custom_response(
+            status_code=status.HTTP_200_OK,
+            content=json.dumps(errors),
         )
 
     notification.send_organization_update(project_id, "records_changed")
-    return pack_json_result({"data": {"editRecords": {"ok": True}}})
+    return get_silent_success()
diff --git a/fast_api/routes/task_execution.py b/fast_api/routes/task_execution.py
index 6b2c49d2..581b3563 100644
--- a/fast_api/routes/task_execution.py
+++ b/fast_api/routes/task_execution.py
@@ -10,7 +10,10 @@
 )
 from fastapi import APIRouter
 from submodules.model import daemon
-from fast_api.routes.client_response import pack_json_result, SILENT_SUCCESS_RESPONSE
+from fast_api.routes.client_response import (
+    get_silent_success,
+    pack_json_result,
+)
 
 router = APIRouter()
 
@@ -29,7 +32,7 @@ def calculate_attributes(
         attribute_calculation_task_execution.attribute_id,
     )
 
-    return SILENT_SUCCESS_RESPONSE
+    return get_silent_success()
 
 
 @router.post(
@@ -64,7 +67,7 @@ def data_slice(
         data_slice_action_execution.embedding_id,
     )
 
-    return SILENT_SUCCESS_RESPONSE
+    return get_silent_success()
 
 
 @router.post(
@@ -80,4 +83,4 @@ def weak_supervision(
         weak_supervision_action_execution.user_id,
     )
 
-    return SILENT_SUCCESS_RESPONSE
+    return get_silent_success()
diff --git a/fast_api/routes/weak_supervision.py b/fast_api/routes/weak_supervision.py
index c01c3a0a..e827c18c 100644
--- a/fast_api/routes/weak_supervision.py
+++ b/fast_api/routes/weak_supervision.py
@@ -2,7 +2,7 @@
 from controller.weak_supervision import manager
 from controller.auth import manager as auth_manager
 from fast_api.models import InitWeakSuperVisionBody, RunThenWeakSupervisionBody
-from fast_api.routes.client_response import pack_json_result
+from fast_api.routes.client_response import get_silent_success
 
 router = APIRouter()
 
@@ -23,9 +23,7 @@ def init_weak_supervision(
         init_body.overwrite_weak_supervision,
     )
 
-    return pack_json_result(
-        {"data": {"initiateWeakSupervisionByProjectId": {"ok": True}}}
-    )
+    return get_silent_success()
 
 
 @router.post(
@@ -41,4 +39,5 @@ def run_then_weak_supervision(
     manager.run_then_weak_supervision(
         project_id, body.heuristic_id, user_id, body.labeling_task_id
     )
-    return pack_json_result({"data": {"runThenWeakSupervision": {"ok": True}}})
+
+    return get_silent_success()
diff --git a/submodules/model b/submodules/model
index 15df3b66..cf337c2d 160000
--- a/submodules/model
+++ b/submodules/model
@@ -1 +1 @@
-Subproject commit 15df3b661f51d892f19f52af874fe5db944c5a4c
+Subproject commit cf337c2d46a302f33ed35419c1d95a60871bbe61
diff --git a/tests/fast_api/routes/test_project.py b/tests/fast_api/routes/test_project.py
index 206aab8a..a6637726 100644
--- a/tests/fast_api/routes/test_project.py
+++ b/tests/fast_api/routes/test_project.py
@@ -12,9 +12,7 @@ def test_get_project_by_project_id(
     )
     assert response.status_code == 200
     response_data = response.json()
-    assert response_data.get("data")
-    assert response_data["data"].get("projectByProjectId")
-    assert response_data["data"]["projectByProjectId"].get("id")
+    assert response_data.get("id")
 
 
 def test_update_project_name_description(
@@ -26,9 +24,7 @@ def test_update_project_name_description(
     )
     assert response.status_code == 200
     response_data = response.json()
-    assert response_data.get("data")
-    assert response_data["data"].get("updateProjectNameDescription")
-    assert response_data["data"]["updateProjectNameDescription"].get("ok")
+    assert response_data.get("ok")
 
     general.refresh(refinery_project)
     assert refinery_project.name == "new_name"