diff --git a/backend/controllers/clubsController.js b/backend/controllers/clubsController.js
index 8248271..46d1074 100644
--- a/backend/controllers/clubsController.js
+++ b/backend/controllers/clubsController.js
@@ -1,8 +1,6 @@
 import ClubService from '../services/clubService.js';
 import { getUserByToken } from '../utils/userUtils.js';
-
-const isDev = process.env.STAGE === 'dev';
-const devLog = (...args) => isDev && console.log(...args);
+import { devLog } from '../utils/logger.js';
 
 export const getClubs = async (req, res) => {
   try {
diff --git a/backend/controllers/diaryController.js b/backend/controllers/diaryController.js
index 98c9452..91bf905 100644
--- a/backend/controllers/diaryController.js
+++ b/backend/controllers/diaryController.js
@@ -1,6 +1,7 @@
 import diaryService from '../services/diaryService.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 const getDatesForClub = async (req, res) => {
     try {
         const { clubId } = req.params; 
@@ -38,7 +39,7 @@ const updateTrainingTimes = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { dateId, trainingStart, trainingEnd } = req.body;
         if (!dateId || !trainingStart) {
-            console.log(dateId, trainingStart, trainingEnd);
+            devLog(dateId, trainingStart, trainingEnd);
             throw new HttpError('notallfieldsfilled', 400);
         }
         const updatedDate = await diaryService.updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd);
diff --git a/backend/controllers/diaryDateActivityController.js b/backend/controllers/diaryDateActivityController.js
index d7ea4ff..3802a47 100644
--- a/backend/controllers/diaryDateActivityController.js
+++ b/backend/controllers/diaryDateActivityController.js
@@ -1,5 +1,6 @@
 import diaryDateActivityService from '../services/diaryDateActivityService.js';
 
+import { devLog } from '../utils/logger.js';
 export const createDiaryDateActivity = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -15,7 +16,7 @@ export const createDiaryDateActivity = async (req, res) => {
         });
         res.status(201).json(activityItem);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error creating activity' });
     }
 };
@@ -58,7 +59,7 @@ export const updateDiaryDateActivityOrder = async (req, res) => {
         const updatedActivity = await diaryDateActivityService.updateActivityOrder(userToken, clubId, id, orderId);
         res.status(200).json(updatedActivity);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error updating activity order' });
     }
 };
@@ -70,7 +71,7 @@ export const getDiaryDateActivities = async (req, res) => {
         const activities = await diaryDateActivityService.getActivities(userToken, clubId, diaryDateId);
         res.status(200).json(activities);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error getting activities' });
     }
 }
@@ -82,7 +83,7 @@ export const addGroupActivity = async(req, res) => {
         const activityItem = await diaryDateActivityService.addGroupActivity(userToken, clubId, diaryDateId, groupId, activity);
         res.status(201).json(activityItem);        
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error adding group activity' });
     }
 }
\ No newline at end of file
diff --git a/backend/controllers/diaryDateTagController.js b/backend/controllers/diaryDateTagController.js
index a6cb707..4bda486 100644
--- a/backend/controllers/diaryDateTagController.js
+++ b/backend/controllers/diaryDateTagController.js
@@ -1,7 +1,8 @@
 import diaryDateTagService from "../services/diaryDateTagService.js"
 
+import { devLog } from '../utils/logger.js';
 export const getDiaryDateMemberTags = async (req, res) => {
-    console.log("getDiaryDateMemberTags");
+    devLog("getDiaryDateMemberTags");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId, memberId } = req.params;
@@ -14,7 +15,7 @@ export const getDiaryDateMemberTags = async (req, res) => {
 }
 
 export const addDiaryDateTag = async (req, res) => {
-    console.log("addDiaryDateTag");
+    devLog("addDiaryDateTag");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;
diff --git a/backend/controllers/diaryMemberController.js b/backend/controllers/diaryMemberController.js
index ba9886f..924db04 100644
--- a/backend/controllers/diaryMemberController.js
+++ b/backend/controllers/diaryMemberController.js
@@ -1,11 +1,12 @@
 import DiaryMemberService from '../services/diaryMemberService.js';
 
+import { devLog } from '../utils/logger.js';
 const getMemberTags = async (req, res) => {
     try {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log(diaryDateId, memberId, clubId);
+        devLog(diaryDateId, memberId, clubId);
         const tags = await DiaryMemberService.getTagsForMemberAndDate(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(tags);
     } catch (error) {
@@ -19,7 +20,7 @@ const getMemberNotes = async (req, res) => {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log('---------->', userToken, clubId);
+        devLog('---------->', userToken, clubId);
         const notes = await DiaryMemberService.getNotesForMember(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(notes);
     } catch (error) {
diff --git a/backend/controllers/diaryTagController.js b/backend/controllers/diaryTagController.js
index 49ddf9c..3aeb7c5 100644
--- a/backend/controllers/diaryTagController.js
+++ b/backend/controllers/diaryTagController.js
@@ -1,5 +1,6 @@
 import { DiaryTag, DiaryDateTag } from '../models/index.js';
 
+import { devLog } from '../utils/logger.js';
 export const getTags = async (req, res) => {
     try {
         const tags = await DiaryTag.findAll();
@@ -12,11 +13,11 @@ export const getTags = async (req, res) => {
 export const createTag = async (req, res) => {
     try {
         const { name } = req.body;
-        console.log(name);
+        devLog(name);
         const newTag = await DiaryTag.findOrCreate({ where: { name }, defaults: { name } });
         res.status(201).json(newTag);
     } catch (error) {
-        console.log('[createTag] - Error:', error);
+        devLog('[createTag] - Error:', error);
         res.status(500).json({ error: 'Error creating tag' });
     }
 };
diff --git a/backend/controllers/groupController.js b/backend/controllers/groupController.js
index ec5c1f2..5ddb95a 100644
--- a/backend/controllers/groupController.js
+++ b/backend/controllers/groupController.js
@@ -1,6 +1,7 @@
 import HttpError from '../exceptions/HttpError.js';
 import groupService from '../services/groupService.js';
 
+import { devLog } from '../utils/logger.js';
 const addGroup = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -9,7 +10,7 @@ const addGroup = async(req, res) => {
         res.status(201).json(result);
     } catch (error) {
         console.error('[addGroup] - Error:', error);
-        console.log(req.params, req.headers, req.body)
+        devLog(req.params, req.headers, req.body)
         res.status(error.statusCode || 500).json({ error: error.message });
     }
 }
diff --git a/backend/controllers/matchController.js b/backend/controllers/matchController.js
index 177cab8..f3f96f3 100644
--- a/backend/controllers/matchController.js
+++ b/backend/controllers/matchController.js
@@ -1,6 +1,7 @@
 import MatchService from '../services/matchService.js';
 import fs from 'fs';
 
+import { devLog } from '../utils/logger.js';
 export const uploadCSV = async (req, res) => {
     try {
         const { clubId } = req.body;
@@ -21,7 +22,7 @@ export const uploadCSV = async (req, res) => {
 
 export const getLeaguesForCurrentSeason = async (req, res) => {
     try {
-        console.log(req.headers, req.params);
+        devLog(req.headers, req.params);
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;
         const leagues = await MatchService.getLeaguesForCurrentSeason(userToken, clubId);
diff --git a/backend/controllers/memberController.js b/backend/controllers/memberController.js
index 190c5e5..1f2d2c0 100644
--- a/backend/controllers/memberController.js
+++ b/backend/controllers/memberController.js
@@ -1,5 +1,6 @@
 import MemberService from "../services/memberService.js";
 
+import { devLog } from '../utils/logger.js';
 const getClubMembers = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -9,24 +10,24 @@ const getClubMembers = async(req, res) => {
         }
         res.status(200).json(await MemberService.getClubMembers(userToken, clubId, showAll));
     } catch(error) {
-        console.log('[getClubMembers] - Error: ', error);
+        devLog('[getClubMembers] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 }
 
 const getWaitingApprovals = async(req, res) => {
     try {
-        console.log('[getWaitingApprovals] - Start');
+        devLog('[getWaitingApprovals] - Start');
         const { id: clubId } = req.params;
-        console.log('[getWaitingApprovals] - get token');
+        devLog('[getWaitingApprovals] - get token');
         const { authcode: userToken } = req.headers;
-        console.log('[getWaitingApprovals] - load for waiting approvals');
+        devLog('[getWaitingApprovals] - load for waiting approvals');
         const waitingApprovals = await MemberService.getApprovalRequests(userToken, clubId);
-        console.log('[getWaitingApprovals] - set response');
+        devLog('[getWaitingApprovals] - set response');
         res.status(200).json(waitingApprovals);
-        console.log('[getWaitingApprovals] - done');
+        devLog('[getWaitingApprovals] - done');
     } catch(error) {
-        console.log('[getWaitingApprovals] - Error: ', error);
+        devLog('[getWaitingApprovals] - Error: ', error);
         res.status(403).json({ error: error });
     }
 } 
@@ -59,7 +60,7 @@ const uploadMemberImage = async (req, res) => {
 };
 
 const getMemberImage = async (req, res) => {
-    console.log('[getMemberImage]');
+    devLog('[getMemberImage]');
     try {
         const { clubId, memberId } = req.params;
         const { authcode: userToken } = req.headers;
@@ -76,7 +77,7 @@ const getMemberImage = async (req, res) => {
 };
 
 const updateRatingsFromMyTischtennis = async (req, res) => {
-    console.log('[updateRatingsFromMyTischtennis]');
+    devLog('[updateRatingsFromMyTischtennis]');
     try {
         const { id: clubId } = req.params;
         const { authcode: userToken } = req.headers;
diff --git a/backend/controllers/memberNoteController.js b/backend/controllers/memberNoteController.js
index a94bd8a..e531a65 100644
--- a/backend/controllers/memberNoteController.js
+++ b/backend/controllers/memberNoteController.js
@@ -1,15 +1,16 @@
 import MemberNoteService from "../services/memberNoteService.js";
 
+import { devLog } from '../utils/logger.js';
 const getMemberNotes = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId } = req.params;
         const { clubId } = req.query;
-        console.log('[getMemberNotes]', userToken, memberId, clubId);
+        devLog('[getMemberNotes]', userToken, memberId, clubId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[getMemberNotes] - Error: ', error);
+        devLog('[getMemberNotes] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -18,12 +19,12 @@ const addMemberNote = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId, content, clubId } = req.body;
-        console.log('[addMemberNote]', userToken, memberId, content, clubId);
+        devLog('[addMemberNote]', userToken, memberId, content, clubId);
         await MemberNoteService.addNoteToMember(userToken, clubId, memberId, content);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(201).json(notes);
     } catch (error) {
-        console.log('[addMemberNote] - Error: ', error);
+        devLog('[addMemberNote] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -33,13 +34,13 @@ const deleteMemberNote = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { noteId } = req.params;
         const { clubId } = req.body;
-        console.log('[deleteMemberNote]', userToken, noteId, clubId);
+        devLog('[deleteMemberNote]', userToken, noteId, clubId);
         const memberId = await MemberNoteService.getMemberIdForNote(noteId); // Member ID ermitteln
         await MemberNoteService.deleteNoteForMember(userToken, clubId, noteId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[deleteMemberNote] - Error: ', error);
+        devLog('[deleteMemberNote] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
diff --git a/backend/controllers/participantController.js b/backend/controllers/participantController.js
index c898908..fe5b83d 100644
--- a/backend/controllers/participantController.js
+++ b/backend/controllers/participantController.js
@@ -1,12 +1,13 @@
 import Participant from '../models/Participant.js';
 
+import { devLog } from '../utils/logger.js';
 export const getParticipants = async (req, res) => {
     try {
         const { dateId } = req.params;
         const participants = await Participant.findAll({ where: { diaryDateId: dateId } });
         res.status(200).json(participants);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Abrufen der Teilnehmer' });
     }
 };
@@ -17,7 +18,7 @@ export const addParticipant = async (req, res) => {
         const participant = await Participant.create({ diaryDateId, memberId });
         res.status(201).json(participant);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Hinzufügen des Teilnehmers' });
     }
 };
@@ -28,7 +29,7 @@ export const removeParticipant = async (req, res) => {
         await Participant.destroy({ where: { diaryDateId, memberId } });
         res.status(200).json({ message: 'Teilnehmer entfernt' });
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Entfernen des Teilnehmers' });
     }
 };
diff --git a/backend/controllers/predefinedActivityImageController.js b/backend/controllers/predefinedActivityImageController.js
index 80e3e94..baad20e 100644
--- a/backend/controllers/predefinedActivityImageController.js
+++ b/backend/controllers/predefinedActivityImageController.js
@@ -5,6 +5,7 @@ import path from 'path';
 import fs from 'fs';
 import sharp from 'sharp';
 
+import { devLog } from '../utils/logger.js';
 export const uploadPredefinedActivityImage = async (req, res) => {
   try {
     const { id } = req.params; // predefinedActivityId
@@ -35,7 +36,7 @@ export const uploadPredefinedActivityImage = async (req, res) => {
 
     // Extrahiere Zeichnungsdaten aus dem Request
     const drawingData = req.body.drawingData ? JSON.parse(req.body.drawingData) : null;
-    console.log('[uploadPredefinedActivityImage] - drawingData:', drawingData);
+    devLog('[uploadPredefinedActivityImage] - drawingData:', drawingData);
 
     const imageRecord = await PredefinedActivityImage.create({
       predefinedActivityId: id,
diff --git a/backend/services/accidentService.js b/backend/services/accidentService.js
index c2b8437..47030ba 100644
--- a/backend/services/accidentService.js
+++ b/backend/services/accidentService.js
@@ -3,6 +3,7 @@ import DiaryDate from '../models/DiaryDates.js';
 import Member from '../models/Member.js';
 import { checkAccess, getUserByToken} from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class AccidentService {
     async createAccident(userToken, clubId, memberId, diaryDateId, accident) {
         await checkAccess(userToken, clubId);
@@ -14,7 +15,7 @@ class AccidentService {
         if (!member || member.clubId != clubId) {
             throw new Error('Member not found');
         }
-        console.log(diaryDateId);
+        devLog(diaryDateId);
         const diaryDate = await DiaryDate.findByPk(diaryDateId);
         if (!diaryDate || diaryDate.clubId != clubId) {
             throw new Error('Diary date not found');
diff --git a/backend/services/authService.js b/backend/services/authService.js
index a054fa0..5bd56a2 100644
--- a/backend/services/authService.js
+++ b/backend/services/authService.js
@@ -4,6 +4,7 @@ import User from '../models/User.js';
 import UserToken from '../models/UserToken.js';
 import { sendActivationEmail } from './emailService.js';
 
+import { devLog } from '../utils/logger.js';
 const register = async (email, password) => {
   try {
     const activationCode = Math.random().toString(36).substring(2, 15);
@@ -11,7 +12,7 @@ const register = async (email, password) => {
     await sendActivationEmail(email, activationCode);
     return user;
   } catch (error) {
-    console.log(error);
+    devLog(error);
     return null;
   }
 };
diff --git a/backend/services/diaryDateActivityService.js b/backend/services/diaryDateActivityService.js
index 9cff7f6..5f5f95a 100644
--- a/backend/services/diaryDateActivityService.js
+++ b/backend/services/diaryDateActivityService.js
@@ -6,12 +6,13 @@ import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
 import { checkAccess } from '../utils/userUtils.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class DiaryDateActivityService {
 
     async createActivity(userToken, clubId, data) {
-        console.log('[DiaryDateActivityService::createActivity] - check user access');
+        devLog('[DiaryDateActivityService::createActivity] - check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::createActivity] - add: ', data);
+        devLog('[DiaryDateActivityService::createActivity] - add: ', data);
         const { activity, ...restData } = data;
         // Versuche, die PredefinedActivity robust zu finden:
         // 1) per übergebener ID
@@ -59,23 +60,23 @@ class DiaryDateActivityService {
         });
         const newOrderId = maxOrderId !== null ? maxOrderId + 1 : 1;
         restData.orderId = newOrderId;
-        console.log('[DiaryDateActivityService::createActivity] - create diary date activity');
+        devLog('[DiaryDateActivityService::createActivity] - create diary date activity');
         return await DiaryDateActivity.create(restData);
     }
 
     async updateActivity(userToken, clubId, id, data) {
-        console.log('[DiaryDateActivityService::updateActivity] - check user access');
+        devLog('[DiaryDateActivityService::updateActivity] - check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::updateActivity] - load activity', id);
+        devLog('[DiaryDateActivityService::updateActivity] - load activity', id);
         const activity = await DiaryDateActivity.findByPk(id);
         if (!activity) {
-            console.log('[DiaryDateActivityService::updateActivity] - activity not found');
+            devLog('[DiaryDateActivityService::updateActivity] - activity not found');
             throw new Error('Activity not found');
         }
 
         // Wenn customActivityName gesendet wird, müssen wir die PredefinedActivity behandeln
         if (data.customActivityName) {
-            console.log('[DiaryDateActivityService::updateActivity] - handling customActivityName:', data.customActivityName);
+            devLog('[DiaryDateActivityService::updateActivity] - handling customActivityName:', data.customActivityName);
             
             // Suche nach einer existierenden PredefinedActivity mit diesem Namen
             let predefinedActivity = await PredefinedActivity.findOne({ 
@@ -84,7 +85,7 @@ class DiaryDateActivityService {
             
             if (!predefinedActivity) {
                 // Erstelle eine neue PredefinedActivity
-                console.log('[DiaryDateActivityService::updateActivity] - creating new PredefinedActivity');
+                devLog('[DiaryDateActivityService::updateActivity] - creating new PredefinedActivity');
                 predefinedActivity = await PredefinedActivity.create({
                     name: data.customActivityName,
                     description: data.description || '',
@@ -99,7 +100,7 @@ class DiaryDateActivityService {
             delete data.customActivityName;
         }
 
-        console.log('[DiaryDateActivityService::updateActivity] - update activity', clubId, id, data, JSON.stringify(data));
+        devLog('[DiaryDateActivityService::updateActivity] - update activity', clubId, id, data, JSON.stringify(data));
         return await activity.update(data);
     }
 
@@ -113,22 +114,22 @@ class DiaryDateActivityService {
     }
 
     async updateActivityOrder(userToken, clubId, id, newOrderId) {
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Start update for activity id: ${id}`);
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - User token: ${userToken}, Club id: ${clubId}, New order id: ${newOrderId}`);
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Checking user access');
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Start update for activity id: ${id}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - User token: ${userToken}, Club id: ${clubId}, New order id: ${newOrderId}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Checking user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::updateActivityOrder] - User access confirmed');
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Finding activity with id: ${id}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - User access confirmed');
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Finding activity with id: ${id}`);
         const activity = await DiaryDateActivity.findByPk(id);
         if (!activity) {
             console.error('[DiaryDateActivityService::updateActivityOrder] - Activity not found, throwing error');
             throw new Error('Activity not found');
         }
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Activity found:', activity);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Activity found:', activity);
         const currentOrderId = activity.orderId;
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Current order id: ${currentOrderId}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Current order id: ${currentOrderId}`);
         if (newOrderId < currentOrderId) {
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Shifting items down. Moving activities with orderId between ${newOrderId} and ${currentOrderId - 1}`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items down. Moving activities with orderId between ${newOrderId} and ${currentOrderId - 1}`);
             await DiaryDateActivity.increment(
                 { orderId: 1 },
                 {
@@ -138,9 +139,9 @@ class DiaryDateActivityService {
                     },
                 }
             );
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Items shifted down`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted down`);
         } else if (newOrderId > currentOrderId) {
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Shifting items up. Moving activities with orderId between ${currentOrderId + 1} and ${newOrderId}`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items up. Moving activities with orderId between ${currentOrderId + 1} and ${newOrderId}`);
             await DiaryDateActivity.decrement(
                 { orderId: 1 },
                 {
@@ -150,16 +151,16 @@ class DiaryDateActivityService {
                     },
                 }
             );
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Items shifted up`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted up`);
         } else {
-            console.log('[DiaryDateActivityService::updateActivityOrder] - New order id is the same as the current order id. No shift required.');
+            devLog('[DiaryDateActivityService::updateActivityOrder] - New order id is the same as the current order id. No shift required.');
         }
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Setting new order id for activity id: ${id}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Setting new order id for activity id: ${id}`);
         activity.orderId = newOrderId;
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Saving activity with new order id');
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Saving activity with new order id');
         const savedActivity = await activity.save();
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Activity saved:', savedActivity);
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Finished update for activity id: ${id}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Activity saved:', savedActivity);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Finished update for activity id: ${id}`);
         return savedActivity;
     }
 
@@ -256,9 +257,9 @@ class DiaryDateActivityService {
     }
 
     async addGroupActivity(userToken, clubId, diaryDateId, groupId, activity) {
-        console.log('[DiaryDateActivityService::addGroupActivity] Check user access');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::addGroupActivity] Check diary date');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check diary date');
         const diaryDateActivity = await DiaryDateActivity.findOne({
             where: {
                 diaryDateId,
@@ -271,26 +272,26 @@ class DiaryDateActivityService {
             console.error('[DiaryDateActivityService::addGroupActivity] Activity not found');
             throw new Error('Activity not found');
         }
-        console.log('[DiaryDateActivityService::addGroupActivity] Check group');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check group');
         const group = await Group.findByPk(groupId);
         if (!group || group.diaryDateId !== diaryDateActivity.diaryDateId) {
             console.error('[DiaryDateActivityService::addGroupActivity] Group and date don\'t fit');
             throw new Error('Group isn\'t related to date');
         }
-        console.log('[DiaryDateActivityService::addGroupActivity] Get predefined activity');
+        devLog('[DiaryDateActivityService::addGroupActivity] Get predefined activity');
         const [predefinedActivity, created] = await PredefinedActivity.findOrCreate({
             where: {
                 name: activity
             }
         });
-        console.log('[DiaryDateActivityService::addGroupActivity] Add group activity');
-        console.log(predefinedActivity);
+        devLog('[DiaryDateActivityService::addGroupActivity] Add group activity');
+        devLog(predefinedActivity);
         const activityData = {
             diaryDateActivity: diaryDateActivity.id,
             groupId: groupId,
             customActivity: predefinedActivity.id
         }
-        console.log(activityData);
+        devLog(activityData);
         return await GroupActivity.create(activityData);
     }
 }
diff --git a/backend/services/diaryDateTagService.js b/backend/services/diaryDateTagService.js
index 74d517c..b0be70f 100644
--- a/backend/services/diaryDateTagService.js
+++ b/backend/services/diaryDateTagService.js
@@ -6,6 +6,7 @@ import Member from "../models/Member.js";
 import { checkAccess } from '../utils/userUtils.js';
 import { Op, literal } from "sequelize";
 
+import { devLog } from '../utils/logger.js';
 class DiaryDateTagService {
     async getDiaryDateMemberTags(userToken, clubId, memberId) {
         await checkAccess(userToken, clubId);
@@ -35,7 +36,7 @@ class DiaryDateTagService {
     }
 
     async addDiaryDateTag(userToken, clubId, diaryDateId, memberId, tag) {
-        console.log(userToken, clubId, diaryDateId, memberId, tag);
+        devLog(userToken, clubId, diaryDateId, memberId, tag);
         await checkAccess(userToken, clubId);
         const tagObject = await DiaryTag.findOne({ where: { id: tag.id } });
         if (!tagObject) {
diff --git a/backend/services/diaryMemberService.js b/backend/services/diaryMemberService.js
index 98cbd78..fdf5649 100644
--- a/backend/services/diaryMemberService.js
+++ b/backend/services/diaryMemberService.js
@@ -3,6 +3,7 @@ import DiaryMemberTag from '../models/DiaryMemberTag.js';
 import { DiaryTag } from '../models/DiaryTag.js';
 import { checkAccess } from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class DiaryMemberService {
     async addNoteToMember(userToken, clubId, diaryDateId, memberId, content) {
         await checkAccess(userToken, clubId);
@@ -14,7 +15,7 @@ class DiaryMemberService {
 
     async getNotesForMember(userToken, clubId, diaryDateId, memberId) {
         await checkAccess(userToken, clubId);
-        console.log(clubId, diaryDateId, memberId);
+        devLog(clubId, diaryDateId, memberId);
         return await DiaryMemberNote.findAll({ where: { diaryDateId, memberId }, order: [['createdAt', 'DESC']] });
     }
 
@@ -50,7 +51,7 @@ class DiaryMemberService {
         if (tagLink) {
             await tagLink.destroy();
         } else {
-            console.log(diaryDateId, memberId, tagId);
+            devLog(diaryDateId, memberId, tagId);
             throw new Error('Das Tag ist nicht verknüpft.');
         }
     }
diff --git a/backend/services/diaryService.js b/backend/services/diaryService.js
index 9ab8cc7..adfb92f 100644
--- a/backend/services/diaryService.js
+++ b/backend/services/diaryService.js
@@ -7,16 +7,17 @@ import DiaryDateTag from '../models/DiaryDateTag.js';
 import { checkAccess } from '../utils/userUtils.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 class DiaryService {
     async getDatesForClub(userToken, clubId) {
-        console.log('[DiaryService::getDatesForClub] - Check user access');
+        devLog('[DiaryService::getDatesForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::getDatesForClub] - Validate club existence');
+        devLog('[DiaryService::getDatesForClub] - Validate club existence');
         const club = await Club.findByPk(clubId);
         if (!club) {
             throw new HttpError('Club not found', 404);
         }
-        console.log('[DiaryService::getDatesForClub] - Load diary dates');
+        devLog('[DiaryService::getDatesForClub] - Load diary dates');
         const dates = await DiaryDate.findAll({
             where: { clubId },
             include: [
@@ -29,14 +30,14 @@ class DiaryService {
     }
 
     async createDateForClub(userToken, clubId, date, trainingStart, trainingEnd) {
-        console.log('[DiaryService::createDateForClub] - Check user access');
+        devLog('[DiaryService::createDateForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::createDateForClub] - Validate club existence');
+        devLog('[DiaryService::createDateForClub] - Validate club existence');
         const club = await Club.findByPk(clubId);
         if (!club) {
             throw new HttpError('Club not found', 404);
         }
-        console.log('[DiaryService::createDateForClub] - Validate date');
+        devLog('[DiaryService::createDateForClub] - Validate date');
         const parsedDate = new Date(date);
         if (isNaN(parsedDate.getTime())) {
             throw new HttpError('Invalid date format', 400);
@@ -44,7 +45,7 @@ class DiaryService {
         if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
             throw new HttpError('Training start time must be before training end time', 400);
         }
-        console.log('[DiaryService::createDateForClub] - Create new diary date');
+        devLog('[DiaryService::createDateForClub] - Create new diary date');
         const newDate = await DiaryDate.create({
             date: parsedDate,
             clubId,
@@ -56,9 +57,9 @@ class DiaryService {
     }
 
     async updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd) {
-        console.log('[DiaryService::updateTrainingTimes] - Check user access');
+        devLog('[DiaryService::updateTrainingTimes] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::updateTrainingTimes] - Validate date');
+        devLog('[DiaryService::updateTrainingTimes] - Validate date');
         const diaryDate = await DiaryDate.findOne({ where: { clubId, id: dateId } });
         if (!diaryDate) {
             throw new HttpError('Diary entry not found', 404);
@@ -66,7 +67,7 @@ class DiaryService {
         if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
             throw new HttpError('Training start time must be before training end time', 400);
         }
-        console.log('[DiaryService::updateTrainingTimes] - Update training times');
+        devLog('[DiaryService::updateTrainingTimes] - Update training times');
         diaryDate.trainingStart = trainingStart || null;
         diaryDate.trainingEnd = trainingEnd || null;
         await diaryDate.save();
@@ -74,14 +75,14 @@ class DiaryService {
     }
 
     async addNoteToDate(userToken, diaryDateId, content) {
-        console.log('[DiaryService::addNoteToDate] - Add note');
+        devLog('[DiaryService::addNoteToDate] - Add note');
         await checkAccess(userToken, diaryDateId);
         await DiaryNote.create({ diaryDateId, content });
         return await DiaryNote.findAll({ where: { diaryDateId }, order: [['createdAt', 'DESC']] });
     }
 
     async deleteNoteFromDate(userToken, noteId) {
-        console.log('[DiaryService::deleteNoteFromDate] - Delete note');
+        devLog('[DiaryService::deleteNoteFromDate] - Delete note');
         const note = await DiaryNote.findByPk(noteId);
         if (!note) {
             throw new HttpError('Note not found', 404);
@@ -92,7 +93,7 @@ class DiaryService {
     }
 
     async addTagToDate(userToken, diaryDateId, tagName) {
-        console.log('[DiaryService::addTagToDate] - Add tag');
+        devLog('[DiaryService::addTagToDate] - Add tag');
         await checkAccess(userToken, diaryDateId);
         let tag = await DiaryTag.findOne({ where: { name: tagName } });
         if (!tag) {
@@ -105,29 +106,29 @@ class DiaryService {
 
     async addTagToDiaryDate(userToken, clubId, diaryDateId, tagId) {
         checkAccess(userToken, clubId);
-        console.log(`[DiaryService::addTagToDiaryDate] - diaryDateId: ${diaryDateId}, tagId: ${tagId}`);
+        devLog(`[DiaryService::addTagToDiaryDate] - diaryDateId: ${diaryDateId}, tagId: ${tagId}`);
         const diaryDate = await DiaryDate.findByPk(diaryDateId);
         if (!diaryDate) {
             throw new HttpError('DiaryDate not found', 404);
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
+        devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
         const existingEntry = await DiaryDateTag.findOne({
             where: { diaryDateId, tagId }
         });
         if (existingEntry) {
             return;
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Tag not found, creating new entry');
+        devLog('[DiaryService::addTagToDiaryDate] - Tag not found, creating new entry');
         const tag = await DiaryTag.findByPk(tagId);  
         if (!tag) {
             throw new HttpError('Tag not found', 404);
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
+        devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
         await DiaryDateTag.create({
             diaryDateId,
             tagId
         });
-        console.log('[DiaryService::addTagToDiaryDate] - Get tags');
+        devLog('[DiaryService::addTagToDiaryDate] - Get tags');
         const tags = await DiaryDateTag.findAll({ where: {
             diaryDateId: diaryDateId },
             include: {
@@ -135,12 +136,12 @@ class DiaryService {
                 as: 'tag'
             }
         });  
-        console.log(tags);
+        devLog(tags);
         return tags.map(tag => tag.tag);
     }
 
     async getDiaryNotesForDateAndMember(diaryDateId, memberId) {
-        console.log('[DiaryService::getDiaryNotesForDateAndMember] - Fetching notes');
+        devLog('[DiaryService::getDiaryNotesForDateAndMember] - Fetching notes');
         return await DiaryNote.findAll({
             where: { diaryDateId, memberId },
             order: [['createdAt', 'DESC']]
@@ -153,19 +154,19 @@ class DiaryService {
     }
 
     async removeDateForClub(userToken, clubId, dateId) {
-        console.log('[DiaryService::removeDateForClub] - Check user access');
+        devLog('[DiaryService::removeDateForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::removeDateForClub] - Validate date');
+        devLog('[DiaryService::removeDateForClub] - Validate date');
         const diaryDate = await DiaryDate.findOne({ where: { id: dateId, clubId } });
         if (!diaryDate) {
             throw new HttpError('Diary entry not found', 404);
         }
-        console.log('[DiaryService::removeDateForClub] - Check for activities');
+        devLog('[DiaryService::removeDateForClub] - Check for activities');
         const activityCount = await DiaryDateActivity.count({ where: { diaryDateId: dateId } });
         if (activityCount > 0) {
             throw new HttpError('Cannot delete date with activities', 409);
         }
-        console.log('[DiaryService::removeDateForClub] - Delete diary date');
+        devLog('[DiaryService::removeDateForClub] - Delete diary date');
         await diaryDate.destroy();
         return { ok: true };
     }
diff --git a/backend/services/groupService.js b/backend/services/groupService.js
index f03afab..13f5a70 100644
--- a/backend/services/groupService.js
+++ b/backend/services/groupService.js
@@ -3,6 +3,7 @@ import DiaryDate from '../models/DiaryDates.js';
 import HttpError from '../exceptions/HttpError.js';
 import Group from '../models/Group.js';
 
+import { devLog } from '../utils/logger.js';
 class GroupService {
 
     async checkDiaryDateToClub(clubId, dateId) {
@@ -40,7 +41,7 @@ class GroupService {
     }
 
     async changeGroup(userToken, groupId, clubId, dateId, name, lead) {
-        console.log("changeGroup: ", groupId, clubId, dateId, name, lead);
+        devLog("changeGroup: ", groupId, clubId, dateId, name, lead);
         await checkAccess(userToken, clubId);
         await this.checkDiaryDateToClub(clubId, dateId);
         const group = await Group.findOne({
diff --git a/backend/services/matchService.js b/backend/services/matchService.js
index ffb0aab..4333bae 100644
--- a/backend/services/matchService.js
+++ b/backend/services/matchService.js
@@ -10,6 +10,7 @@ import Team from '../models/Team.js';
 import { checkAccess } from '../utils/userUtils.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class MatchService {
 
     generateSeasonString(date = new Date()) {
@@ -78,7 +79,7 @@ class MatchService {
             return result;
 
         } catch (error) {
-            console.log('Error during CSV import:', error);
+            devLog('Error during CSV import:', error);
             throw error;
         }
     }
diff --git a/backend/services/memberNoteService.js b/backend/services/memberNoteService.js
index 43a6bf8..e9b4d5b 100644
--- a/backend/services/memberNoteService.js
+++ b/backend/services/memberNoteService.js
@@ -1,6 +1,7 @@
 import MemberNote from '../models/MemberNote.js';
 import { checkAccess } from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class MemberNoteService {
     async addNoteToMember(userToken, clubId, memberId, content) {
         await checkAccess(userToken, clubId);
@@ -8,7 +9,7 @@ class MemberNoteService {
     }
 
     async getNotesForMember(userToken, clubId, memberId) {
-        console.log(userToken, clubId);
+        devLog(userToken, clubId);
         await checkAccess(userToken, clubId);
         return await MemberNote.findAll({ 
             where: { memberId },
diff --git a/backend/services/memberService.js b/backend/services/memberService.js
index 8c66e9b..cf2de6c 100644
--- a/backend/services/memberService.js
+++ b/backend/services/memberService.js
@@ -6,13 +6,14 @@ import path from 'path';
 import fs from 'fs';
 import sharp from 'sharp';
 
+import { devLog } from '../utils/logger.js';
 class MemberService {
     async getApprovalRequests(userToken, clubId) {
-        console.log('[MemberService::getApprovalRequest] - Check user access');
+        devLog('[MemberService::getApprovalRequest] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[MemberService::getApprovalRequest] - Load user');
+        devLog('[MemberService::getApprovalRequest] - Load user');
         const user = await getUserByToken(userToken);
-        console.log('[MemberService::getApprovalRequest] - Load userclub');
+        devLog('[MemberService::getApprovalRequest] - Load userclub');
         return await UserClub.findAll({
             where: {
                 clubId: clubId,
@@ -23,9 +24,9 @@ class MemberService {
     }
 
     async getClubMembers(userToken, clubId, showAll) {
-        console.log('[getClubMembers] - Check access');
+        devLog('[getClubMembers] - Check access');
         await checkAccess(userToken, clubId);
-        console.log('[getClubMembers] - Find members');
+        devLog('[getClubMembers] - Find members');
         const where = {
             clubId: clubId
         };
@@ -44,7 +45,7 @@ class MemberService {
                 });
             })
             .then(membersWithImageStatus => {
-                console.log('[getClubMembers] - return members');
+                devLog('[getClubMembers] - return members');
                 return membersWithImageStatus;
             })
             .catch(error => {
@@ -56,15 +57,15 @@ class MemberService {
     async setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, birthdate, phone, email, active = true, testMembership = false,
         picsInInternetAllowed = false, gender = 'unknown', ttr = null, qttr = null) {
         try {
-            console.log('[setClubMembers] - Check access');
+            devLog('[setClubMembers] - Check access');
             await checkAccess(userToken, clubId);
-            console.log('[setClubMembers] - set default member');
+            devLog('[setClubMembers] - set default member');
             let member = null;
-            console.log('[setClubMembers] - load member if possible');
+            devLog('[setClubMembers] - load member if possible');
             if (memberId) {
                 member = await Member.findOne({ where: { id: memberId } });
             }
-            console.log('[setClubMembers] - set member');
+            devLog('[setClubMembers] - set member');
             if (member) {
                 member.firstName = firstName;
                 member.lastName = lastName;
@@ -98,13 +99,13 @@ class MemberService {
                     qttr: qttr,
                 });
             }
-            console.log('[setClubMembers] - return response');
+            devLog('[setClubMembers] - return response');
             return {
                 status: 200,
                 response: { result: "success" },
             }
         } catch (error) {
-            console.log(error);
+            devLog(error);
             return {
                 status: error.statusCode || 500,
                 response: { error: "nocreation" }
@@ -114,7 +115,7 @@ class MemberService {
 
     async uploadMemberImage(userToken, clubId, memberId, imageBuffer) {
         try {
-            console.log('------>', userToken, clubId, memberId, imageBuffer);
+            devLog('------>', userToken, clubId, memberId, imageBuffer);
             await checkAccess(userToken, clubId);
             const member = await Member.findOne({ where: { id: memberId, clubId: clubId } });
             if (!member) {
@@ -152,27 +153,27 @@ class MemberService {
     }
 
     async updateRatingsFromMyTischtennis(userToken, clubId) {
-        console.log('[updateRatingsFromMyTischtennis] - Check access');
+        devLog('[updateRatingsFromMyTischtennis] - Check access');
         await checkAccess(userToken, clubId);
         
         const user = await getUserByToken(userToken);
-        console.log('[updateRatingsFromMyTischtennis] - User:', user.id);
+        devLog('[updateRatingsFromMyTischtennis] - User:', user.id);
         
         const myTischtennisService = (await import('./myTischtennisService.js')).default;
         const myTischtennisClient = (await import('../clients/myTischtennisClient.js')).default;
         
         try {
             // 1. myTischtennis-Session abrufen
-            console.log('[updateRatingsFromMyTischtennis] - Get session for user', user.id);
+            devLog('[updateRatingsFromMyTischtennis] - Get session for user', user.id);
             const session = await myTischtennisService.getSession(user.id);
-            console.log('[updateRatingsFromMyTischtennis] - Session retrieved:', {
+            devLog('[updateRatingsFromMyTischtennis] - Session retrieved:', {
                 hasAccessToken: !!session.accessToken,
                 hasCookie: !!session.cookie,
                 expiresAt: session.expiresAt
             });
             
             const account = await myTischtennisService.getAccount(user.id);
-            console.log('[updateRatingsFromMyTischtennis] - Account data:', {
+            devLog('[updateRatingsFromMyTischtennis] - Account data:', {
                 id: account?.id,
                 email: account?.email,
                 clubId: account?.clubId,
@@ -216,7 +217,7 @@ class MemberService {
             }
             
             // 2. Rangliste vom Verein abrufen
-            console.log('[updateRatingsFromMyTischtennis] - Get club rankings', {
+            devLog('[updateRatingsFromMyTischtennis] - Get club rankings', {
                 clubId: account.clubId,
                 fedNickname: account.fedNickname,
                 hasCookie: !!session.cookie
@@ -228,7 +229,7 @@ class MemberService {
                 account.fedNickname
             );
             
-            console.log('[updateRatingsFromMyTischtennis] - Rankings result:', {
+            devLog('[updateRatingsFromMyTischtennis] - Rankings result:', {
                 success: rankings.success,
                 entriesCount: rankings.entries?.length || 0,
                 error: rankings.error
@@ -251,9 +252,9 @@ class MemberService {
             }
             
             // 3. Alle Mitglieder des Clubs laden
-            console.log('[updateRatingsFromMyTischtennis] - Load club members for clubId:', clubId);
+            devLog('[updateRatingsFromMyTischtennis] - Load club members for clubId:', clubId);
             const members = await Member.findAll({ where: { clubId } });
-            console.log('[updateRatingsFromMyTischtennis] - Found members:', members.length);
+            devLog('[updateRatingsFromMyTischtennis] - Found members:', members.length);
             
             let updated = 0;
             const errors = [];
@@ -284,7 +285,7 @@ class MemberService {
                             oldTtr: oldTtr,
                             newTtr: rankingEntry.fedRank
                         });
-                        console.log(`[updateRatingsFromMyTischtennis] - Updated ${firstName} ${lastName}: TTR ${oldTtr} → ${rankingEntry.fedRank}`);
+                        devLog(`[updateRatingsFromMyTischtennis] - Updated ${firstName} ${lastName}: TTR ${oldTtr} → ${rankingEntry.fedRank}`);
                     } catch (error) {
                         console.error(`[updateRatingsFromMyTischtennis] - Error updating ${firstName} ${lastName}:`, error);
                         errors.push({
@@ -294,12 +295,12 @@ class MemberService {
                     }
                 } else {
                     notFound.push(`${firstName} ${lastName}`);
-                    console.log(`[updateRatingsFromMyTischtennis] - Not found in rankings: ${firstName} ${lastName}`);
+                    devLog(`[updateRatingsFromMyTischtennis] - Not found in rankings: ${firstName} ${lastName}`);
                 }
             }
             
-            console.log('[updateRatingsFromMyTischtennis] - Update complete');
-            console.log(`Updated: ${updated}, Not found: ${notFound.length}, Errors: ${errors.length}`);
+            devLog('[updateRatingsFromMyTischtennis] - Update complete');
+            devLog(`Updated: ${updated}, Not found: ${notFound.length}, Errors: ${errors.length}`);
             
             let message = `${updated} Mitglied(er) aktualisiert.`;
             if (notFound.length > 0) {
diff --git a/backend/services/myTischtennisService.js b/backend/services/myTischtennisService.js
index ac7c0a9..65f6a8b 100644
--- a/backend/services/myTischtennisService.js
+++ b/backend/services/myTischtennisService.js
@@ -3,6 +3,7 @@ import User from '../models/User.js';
 import myTischtennisClient from '../clients/myTischtennisClient.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 class MyTischtennisService {
   /**
    * Get myTischtennis account for user
@@ -67,9 +68,9 @@ class MyTischtennisService {
         account.userData = loginResult.user;
         
         // Hole Club-ID und Federation
-        console.log('[myTischtennisService] - Getting user profile...');
+        devLog('[myTischtennisService] - Getting user profile...');
         const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
-        console.log('[myTischtennisService] - Profile result:', {
+        devLog('[myTischtennisService] - Profile result:', {
           success: profileResult.success,
           clubId: profileResult.clubId,
           clubName: profileResult.clubName,
@@ -80,7 +81,7 @@ class MyTischtennisService {
           account.clubId = profileResult.clubId;
           account.clubName = profileResult.clubName;
           account.fedNickname = profileResult.fedNickname;
-          console.log('[myTischtennisService] - Updated account with club data');
+          devLog('[myTischtennisService] - Updated account with club data');
         } else {
           console.error('[myTischtennisService] - Failed to get profile:', profileResult.error);
         }
@@ -176,9 +177,9 @@ class MyTischtennisService {
       account.userData = loginResult.user;
       
       // Hole Club-ID und Federation
-      console.log('[myTischtennisService] - Getting user profile...');
+      devLog('[myTischtennisService] - Getting user profile...');
       const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
-      console.log('[myTischtennisService] - Profile result:', {
+      devLog('[myTischtennisService] - Profile result:', {
         success: profileResult.success,
         clubId: profileResult.clubId,
         clubName: profileResult.clubName,
@@ -189,7 +190,7 @@ class MyTischtennisService {
         account.clubId = profileResult.clubId;
         account.clubName = profileResult.clubName;
         account.fedNickname = profileResult.fedNickname;
-        console.log('[myTischtennisService] - Updated account with club data');
+        devLog('[myTischtennisService] - Updated account with club data');
       } else {
         console.error('[myTischtennisService] - Failed to get profile:', profileResult.error);
       }
diff --git a/backend/services/predefinedActivityService.js b/backend/services/predefinedActivityService.js
index 2dd9cdd..5f366ce 100644
--- a/backend/services/predefinedActivityService.js
+++ b/backend/services/predefinedActivityService.js
@@ -5,9 +5,10 @@ import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
 import sequelize from '../database.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class PredefinedActivityService {
     async createPredefinedActivity(data) {
-        console.log('[PredefinedActivityService::createPredefinedActivity] - Creating predefined activity');
+        devLog('[PredefinedActivityService::createPredefinedActivity] - Creating predefined activity');
         return await PredefinedActivity.create({
             name: data.name,
             code: data.code,
@@ -20,10 +21,10 @@ class PredefinedActivityService {
     }
 
     async updatePredefinedActivity(id, data) {
-        console.log(`[PredefinedActivityService::updatePredefinedActivity] - Updating predefined activity with id: ${id}`);
+        devLog(`[PredefinedActivityService::updatePredefinedActivity] - Updating predefined activity with id: ${id}`);
         const activity = await PredefinedActivity.findByPk(id);
         if (!activity) {
-            console.log('[PredefinedActivityService::updatePredefinedActivity] - Activity not found');
+            devLog('[PredefinedActivityService::updatePredefinedActivity] - Activity not found');
             throw new Error('Predefined activity not found');
         }
         return await activity.update({
@@ -38,7 +39,7 @@ class PredefinedActivityService {
     }
 
     async getAllPredefinedActivities() {
-        console.log('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
+        devLog('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
         return await PredefinedActivity.findAll({
             order: [
                 [sequelize.literal('code IS NULL'), 'ASC'], // Non-null codes first
@@ -49,10 +50,10 @@ class PredefinedActivityService {
     }
 
     async getPredefinedActivityById(id) {
-        console.log(`[PredefinedActivityService::getPredefinedActivityById] - Fetching predefined activity with id: ${id}`);
+        devLog(`[PredefinedActivityService::getPredefinedActivityById] - Fetching predefined activity with id: ${id}`);
         const activity = await PredefinedActivity.findByPk(id);
         if (!activity) {
-            console.log('[PredefinedActivityService::getPredefinedActivityById] - Activity not found');
+            devLog('[PredefinedActivityService::getPredefinedActivityById] - Activity not found');
             throw new Error('Predefined activity not found');
         }
         return activity;
@@ -80,7 +81,7 @@ class PredefinedActivityService {
     }
 
     async mergeActivities(sourceId, targetId) {
-        console.log(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
+        devLog(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
         if (!sourceId || !targetId) throw new Error('sourceId and targetId are required');
         if (Number(sourceId) === Number(targetId)) throw new Error('sourceId and targetId must differ');
 
@@ -120,7 +121,7 @@ class PredefinedActivityService {
     }
 
     async deduplicateActivities() {
-        console.log('[PredefinedActivityService::deduplicateActivities] - Start');
+        devLog('[PredefinedActivityService::deduplicateActivities] - Start');
         const all = await PredefinedActivity.findAll();
         const nameToActivities = new Map();
         for (const activity of all) {
@@ -142,7 +143,7 @@ class PredefinedActivityService {
                 mergedCount++;
             }
         }
-        console.log('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
+        devLog('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
         return { mergedCount, groupCount };
     }
 }
diff --git a/backend/services/tournamentService.js b/backend/services/tournamentService.js
index dc7ffcb..67f1934 100644
--- a/backend/services/tournamentService.js
+++ b/backend/services/tournamentService.js
@@ -9,6 +9,7 @@ import { checkAccess } from '../utils/userUtils.js';
 import { Op, literal } from 'sequelize';
 
 
+import { devLog } from '../utils/logger.js';
 function getRoundName(size) {
     switch (size) {
         case 2: return "Finale";
@@ -186,7 +187,7 @@ class TournamentService {
         
         if (alreadyAssigned.length > 0) {
             // Spieler sind bereits manuell zugeordnet - nicht neu verteilen
-            console.log(`${alreadyAssigned.length} Spieler bereits zugeordnet, ${unassigned.length} noch nicht zugeordnet`);
+            devLog(`${alreadyAssigned.length} Spieler bereits zugeordnet, ${unassigned.length} noch nicht zugeordnet`);
         } else {
             // Keine manuellen Zuordnungen - zufällig verteilen
             const shuffled = members.slice();
@@ -202,11 +203,11 @@ class TournamentService {
         }
 
         // 4) Round‑Robin anlegen wie gehabt - NUR innerhalb jeder Gruppe
-        console.log(`[fillGroups] Erstelle Matches für ${groups.length} Gruppen`);
+        devLog(`[fillGroups] Erstelle Matches für ${groups.length} Gruppen`);
         for (const g of groups) {
-            console.log(`[fillGroups] Verarbeite Gruppe ${g.id}`);
+            devLog(`[fillGroups] Verarbeite Gruppe ${g.id}`);
             const gm = await TournamentMember.findAll({ where: { groupId: g.id } });
-            console.log(`[fillGroups] Gruppe ${g.id} hat ${gm.length} Teilnehmer:`, gm.map(m => ({ id: m.id, name: m.member?.firstName + ' ' + m.member?.lastName })));
+            devLog(`[fillGroups] Gruppe ${g.id} hat ${gm.length} Teilnehmer:`, gm.map(m => ({ id: m.id, name: m.member?.firstName + ' ' + m.member?.lastName })));
             
             if (gm.length < 2) {
                 console.warn(`Gruppe ${g.id} hat nur ${gm.length} Teilnehmer - keine Matches erstellt`);
@@ -214,10 +215,10 @@ class TournamentService {
             }
             
             const rounds = this.generateRoundRobinSchedule(gm);
-            console.log(`[fillGroups] Gruppe ${g.id} hat ${rounds.length} Runden`);
+            devLog(`[fillGroups] Gruppe ${g.id} hat ${rounds.length} Runden`);
             
             for (let roundIndex = 0; roundIndex < rounds.length; roundIndex++) {
-                console.log(`[fillGroups] Runde ${roundIndex + 1} für Gruppe ${g.id}:`, rounds[roundIndex]);
+                devLog(`[fillGroups] Runde ${roundIndex + 1} für Gruppe ${g.id}:`, rounds[roundIndex]);
                 for (const [p1Id, p2Id] of rounds[roundIndex]) {
                     // Prüfe, ob beide Spieler zur gleichen Gruppe gehören
                     const p1 = gm.find(p => p.id === p1Id);
@@ -231,7 +232,7 @@ class TournamentService {
                             player2Id: p2Id,
                             groupRound: roundIndex + 1
                         });
-                        console.log(`[fillGroups] Match erstellt: ${match.id} - Spieler ${p1Id} vs ${p2Id} in Gruppe ${g.id}`);
+                        devLog(`[fillGroups] Match erstellt: ${match.id} - Spieler ${p1Id} vs ${p2Id} in Gruppe ${g.id}`);
                     } else {
                         console.warn(`Spieler gehören nicht zur gleichen Gruppe: ${p1Id} (${p1?.groupId}) vs ${p2Id} (${p2?.groupId}) in Gruppe ${g.id}`);
                     }
diff --git a/backend/utils/logger.js b/backend/utils/logger.js
new file mode 100644
index 0000000..716c14f
--- /dev/null
+++ b/backend/utils/logger.js
@@ -0,0 +1,19 @@
+// Zentrale Logger-Utility für dev/prod Umgebungen
+const isDev = process.env.STAGE === 'dev';
+
+// Debug-Logs nur im dev-Modus
+export const devLog = (...args) => isDev && console.log(...args);
+
+// Fehler-Logs immer ausgeben
+export const errorLog = (...args) => console.error(...args);
+
+// Info-Logs immer ausgeben (für wichtige Produktions-Events)
+export const infoLog = (...args) => console.log(...args);
+
+export default {
+  devLog,
+  errorLog,
+  infoLog,
+  isDev
+};
+
diff --git a/backend/utils/userUtils.js b/backend/utils/userUtils.js
index ea1f3aa..ebf3b52 100644
--- a/backend/utils/userUtils.js
+++ b/backend/utils/userUtils.js
@@ -2,14 +2,12 @@ import jwt from 'jsonwebtoken';
 import { Op } from 'sequelize';
 import User from '../models/User.js';
 import UserToken from '../models/UserToken.js';
-import UserClub from '../models/UserClub.js';    // <-- hier hinzufügen
+import UserClub from '../models/UserClub.js';
 import HttpError from '../exceptions/HttpError.js';
 import { config } from 'dotenv';
+import { devLog } from './logger.js';
 config(); // sorgt dafür, dass process.env.JWT_SECRET geladen wird
 
-const isDev = process.env.STAGE === 'dev';
-const devLog = (...args) => isDev && console.log(...args);
-
 export const getUserByToken = async (token) => {
     try {
         // 1. JWT validieren