diff --git a/backend/controllers/matchController.js b/backend/controllers/matchController.js
index d71155f7..47cd4f08 100755
--- a/backend/controllers/matchController.js
+++ b/backend/controllers/matchController.js
@@ -176,7 +176,7 @@ export const getMatchPlayers = async (req, res) => {
         const Member = (await import('../models/Member.js')).default;
         const members = await Member.findAll({
             where: { clubId: clubId, active: true },
-            attributes: ['id', 'firstName', 'lastName', 'gender']
+            attributes: ['id', 'firstName', 'lastName', 'gender', 'ttr', 'qttr', 'ttrAdjustmentConstant']
         });
         return res.status(200).json(members);
     } catch (error) {
diff --git a/backend/migrations/20261005_add_hidden_test_user_flags.sql b/backend/migrations/20261005_add_hidden_test_user_flags.sql
new file mode 100644
index 00000000..0b564df3
--- /dev/null
+++ b/backend/migrations/20261005_add_hidden_test_user_flags.sql
@@ -0,0 +1,5 @@
+-- Hidden application-review users do not appear in club member/user lists
+-- and must never receive outgoing emails.
+ALTER TABLE `user`
+  ADD COLUMN `is_hidden` TINYINT(1) NOT NULL DEFAULT 0,
+  ADD COLUMN `suppress_emails` TINYINT(1) NOT NULL DEFAULT 0;
diff --git a/backend/migrations/20261005_add_member_ttr_adjustment_constant.sql b/backend/migrations/20261005_add_member_ttr_adjustment_constant.sql
new file mode 100644
index 00000000..ed9fe068
--- /dev/null
+++ b/backend/migrations/20261005_add_member_ttr_adjustment_constant.sql
@@ -0,0 +1,2 @@
+ALTER TABLE `member`
+  ADD COLUMN `ttr_adjustment_constant` DECIMAL(6,2) NOT NULL DEFAULT 16;
diff --git a/backend/models/Member.js b/backend/models/Member.js
index 2d85e9e7..c21919f9 100755
--- a/backend/models/Member.js
+++ b/backend/models/Member.js
@@ -214,6 +214,13 @@ const Member = sequelize.define('Member', {
     allowNull: true,
     defaultValue: null
   },
+  ttrAdjustmentConstant: {
+    type: DataTypes.DECIMAL(6, 2),
+    allowNull: false,
+    defaultValue: 16,
+    field: 'ttr_adjustment_constant',
+    comment: 'Individuelle Änderungskonstante für TTR-Prognosen'
+  },
   qttr: {
     type: DataTypes.INTEGER,
     allowNull: true,
diff --git a/backend/models/User.js b/backend/models/User.js
index 10e0f262..dfc6300a 100755
--- a/backend/models/User.js
+++ b/backend/models/User.js
@@ -34,6 +34,20 @@ const User = sequelize.define('User', {
     type: DataTypes.BOOLEAN,
     defaultValue: false,
   },
+  isHidden: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'is_hidden',
+    comment: 'System accounts hidden from member and user lists',
+  },
+  suppressEmails: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'suppress_emails',
+    comment: 'Do not deliver outgoing emails to this account',
+  },
   authCode: {
     type: DataTypes.STRING,
     allowNull: true
diff --git a/backend/scripts/createTestUsers.js b/backend/scripts/createTestUsers.js
index adaf3416..25bfb380 100755
--- a/backend/scripts/createTestUsers.js
+++ b/backend/scripts/createTestUsers.js
@@ -12,7 +12,9 @@ const TEST_USERS = [
     email: 'admin@test.de',
     password: 'test123',
     role: 'admin',
-    isOwner: false
+    isOwner: false,
+    isHidden: true,
+    suppressEmails: true
   },
   {
     email: 'trainer@test.de',
@@ -75,11 +77,21 @@ async function createTestUsers() {
         user = await User.create({
           email: userData.email,
           password: userData.password,
-          isActive: true
+          isActive: true,
+          isHidden: Boolean(userData.isHidden),
+          suppressEmails: Boolean(userData.suppressEmails),
         });
         report.push('  ✓ User created');
       }
 
+      if (user.isHidden !== Boolean(userData.isHidden) || user.suppressEmails !== Boolean(userData.suppressEmails)) {
+        await user.update({
+          isHidden: Boolean(userData.isHidden),
+          suppressEmails: Boolean(userData.suppressEmails),
+        });
+        report.push('  ✓ Updated test account visibility and email settings');
+      }
+
       // Check if user is already in club
       let userClub = await UserClub.findOne({
         where: {
@@ -145,4 +157,3 @@ createTestUsers().catch(err => {
   process.exit(1);
 });
 
-
diff --git a/backend/scripts/runMigrations.js b/backend/scripts/runMigrations.js
index 1e55c199..0bd27fb1 100644
--- a/backend/scripts/runMigrations.js
+++ b/backend/scripts/runMigrations.js
@@ -1,6 +1,29 @@
 import sequelize from '../database.js';
 
 const migrations = [
+  {
+    id: '20261005_add_hidden_test_user_flags',
+    async up() {
+      const [hiddenColumns] = await sequelize.query("SHOW COLUMNS FROM `user` LIKE 'is_hidden'");
+      if (hiddenColumns.length === 0) {
+        await sequelize.query('ALTER TABLE `user` ADD COLUMN `is_hidden` TINYINT(1) NOT NULL DEFAULT 0');
+      }
+
+      const [emailSuppressionColumns] = await sequelize.query("SHOW COLUMNS FROM `user` LIKE 'suppress_emails'");
+      if (emailSuppressionColumns.length === 0) {
+        await sequelize.query('ALTER TABLE `user` ADD COLUMN `suppress_emails` TINYINT(1) NOT NULL DEFAULT 0');
+      }
+    },
+  },
+  {
+    id: '20261005_add_member_ttr_adjustment_constant',
+    async up() {
+      const [columns] = await sequelize.query("SHOW COLUMNS FROM `member` LIKE 'ttr_adjustment_constant'");
+      if (columns.length === 0) {
+        await sequelize.query('ALTER TABLE `member` ADD COLUMN `ttr_adjustment_constant` DECIMAL(6,2) NOT NULL DEFAULT 16');
+      }
+    },
+  },
   {
     id: '20260922_add_match_player_cancellations',
     async up() {
diff --git a/backend/services/clubService.js b/backend/services/clubService.js
index e04e1241..e771412d 100755
--- a/backend/services/clubService.js
+++ b/backend/services/clubService.js
@@ -59,6 +59,8 @@ class ClubService {
                 {
                     model: User,
                     as: 'Users',
+                    where: { isHidden: false },
+                    required: false,
                     through: {
                         attributes: []
                     }
@@ -224,6 +226,8 @@ class ClubService {
                 {
                     model: User,
                     as: 'user',
+                    where: { isHidden: false },
+                    required: true,
                 }
             ]
         });
diff --git a/backend/services/emailService.js b/backend/services/emailService.js
index 35c29004..aadfe354 100755
--- a/backend/services/emailService.js
+++ b/backend/services/emailService.js
@@ -1,4 +1,5 @@
 import nodemailer from 'nodemailer';
+import User from '../models/User.js';
 
 let transporter = null;
 
@@ -38,7 +39,32 @@ function getEmailTransportStatus() {
   };
 }
 
+function normalizeRecipientList(recipients) {
+  const values = Array.isArray(recipients) ? recipients : [recipients];
+  return values
+    .flatMap((value) => String(value || '').split(','))
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
 async function sendMail(mailOptions) {
+  const recipients = normalizeRecipientList(mailOptions.to);
+  if (recipients.length) {
+    const suppressedUsers = await User.findAll({
+      where: { email: recipients, suppressEmails: true },
+      attributes: ['email'],
+    });
+    const suppressedEmails = new Set(suppressedUsers.map((user) => String(user.email).toLowerCase()));
+    const allowedRecipients = recipients.filter((email) => !suppressedEmails.has(email));
+
+    if (!allowedRecipients.length) {
+      console.info('[email] Delivery suppressed for hidden test account');
+      return { suppressed: true, accepted: [], rejected: [] };
+    }
+
+    mailOptions = { ...mailOptions, to: allowedRecipients.join(', ') };
+  }
+
   return getTransporter().sendMail({
     from: getDefaultFrom(),
     ...mailOptions,
diff --git a/backend/services/memberService.js b/backend/services/memberService.js
index e765c921..5b281e65 100755
--- a/backend/services/memberService.js
+++ b/backend/services/memberService.js
@@ -1,4 +1,5 @@
 import UserClub from "../models/UserClub.js";
+import User from "../models/User.js";
 import Club from "../models/Club.js";
 import { checkAccess, getUserByToken, hasUserClubAccess } from "../utils/userUtils.js";
 import Member from "../models/Member.js";
@@ -221,6 +222,17 @@ class MemberService {
         if (!showAll || showAll === 'false') {
             where['active'] = true;
         }
+        const hiddenUsers = await User.findAll({
+            where: { isHidden: true },
+            attributes: ['id'],
+        });
+        const hiddenUserIds = hiddenUsers.map((user) => user.id);
+        if (hiddenUserIds.length) {
+            where[Op.or] = [
+                { userId: null },
+                { userId: { [Op.notIn]: hiddenUserIds } },
+            ];
+        }
         const MemberContact = (await import('../models/MemberContact.js')).default;
         try {
             const members = await Member.findAll({
diff --git a/backend/services/permissionService.js b/backend/services/permissionService.js
index f4aa18ff..8002cdd0 100755
--- a/backend/services/permissionService.js
+++ b/backend/services/permissionService.js
@@ -474,7 +474,13 @@ class PermissionService {
 
     const userClubs = await UserClub.findAll({
       where: { clubId },
-      include: [{ model: User, as: 'user', attributes: ['id', 'email'] }],
+      include: [{
+        model: User,
+        as: 'user',
+        attributes: ['id', 'email'],
+        where: { isHidden: false },
+        required: true,
+      }],
       order: [[{ model: User, as: 'user' }, 'email', 'ASC']],
     });
 
diff --git a/frontend/package.json b/frontend/package.json
index 80cf0550..0e32bb01 100755
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -5,6 +5,7 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build",
+    "test": "node --test tests/*.test.mjs",
     "serve": "vite preview",
     "i18n:audit": "node scripts/audit-i18n.js",
     "i18n:status": "node scripts/translation-status.js",
diff --git a/frontend/src/components/DialogManager.vue b/frontend/src/components/DialogManager.vue
index e6edad35..ee26ecf0 100755
--- a/frontend/src/components/DialogManager.vue
+++ b/frontend/src/components/DialogManager.vue
@@ -58,6 +58,7 @@ import { mapGetters, mapActions } from 'vuex';
 import MatchReportDialog from './MatchReportDialog.vue';
 import MatchReportApiDialog from './MatchReportApiDialog.vue';
 import MatchReportHeaderActions from './MatchReportHeaderActions.vue';
+import TtrSimulatorDialog from './TtrSimulatorDialog.vue';
 
 const MyTischtennisAccount = defineAsyncComponent(() => import('../views/MyTischtennisAccount.vue'));
 const ClickTtAccount = defineAsyncComponent(() => import('../views/ClickTtAccount.vue'));
@@ -78,6 +79,7 @@ export default {
     MatchReportDialog,
     MatchReportApiDialog,
     MatchReportHeaderActions,
+    TtrSimulatorDialog,
     MyTischtennisAccount,
     ClickTtAccount,
     PermissionsView,
@@ -130,6 +132,7 @@ export default {
         'MatchReportDialog': MatchReportDialog,
         'MatchReportApiDialog': MatchReportApiDialog,
         'MatchReportHeaderActions': MatchReportHeaderActions,
+        'TtrSimulatorDialog': TtrSimulatorDialog,
         'MyTischtennisAccount': MyTischtennisAccount,
         'ClickTtAccount': ClickTtAccount,
         'PermissionsView': PermissionsView,
diff --git a/frontend/src/components/TtrSimulatorDialog.vue b/frontend/src/components/TtrSimulatorDialog.vue
new file mode 100644
index 00000000..82c1672c
--- /dev/null
+++ b/frontend/src/components/TtrSimulatorDialog.vue
@@ -0,0 +1,155 @@
+<template>
+  <div class="ttr-simulator">
+    <p class="intro">Berechnung mit dem TTR-Snapshot vor der Veranstaltung. Der angezeigte neue Wert ist voraussichtlich, nicht offiziell.</p>
+
+    <div class="form-grid">
+      <label v-if="clubId">
+        Spieler aus dem Verein
+        <select v-model="selectedMemberId" :disabled="membersLoading" @change="applySelectedMember">
+          <option value="">{{ membersLoading ? 'Spieler werden geladen …' : 'Manuelle Eingabe' }}</option>
+          <option v-for="member in membersWithTtr" :key="member.id" :value="String(member.id)">
+            {{ member.firstName }} {{ member.lastName }} · TTR {{ member.ttr }}
+          </option>
+        </select>
+      </label>
+      <label>
+        Eigener TTR-Snapshot
+        <input v-model.number="ownTtr" min="0" step="1" type="number" />
+      </label>
+      <label>
+        Änderungskonstante (A-Wert)
+        <input v-model.number="adjustmentConstant" min="0" step="0.1" type="number" />
+      </label>
+    </div>
+
+    <section>
+      <div class="section-heading">
+        <h4>Einzelbegegnungen</h4>
+        <button type="button" class="btn-secondary" @click="addMatch">Einzel hinzufügen</button>
+      </div>
+      <div v-for="(match, index) in matches" :key="match.id" class="match-row">
+        <input v-model.trim="match.name" aria-label="Name des Gegners" placeholder="Gegner" type="text" />
+        <input v-model.number="match.opponentTtr" aria-label="TTR des Gegners" min="0" placeholder="Gegner-TTR" step="1" type="number" />
+        <select v-model="match.result" aria-label="Ergebnis">
+          <option value="win">Sieg</option>
+          <option value="loss">Niederlage</option>
+        </select>
+        <span v-if="calculationFor(index)" class="single-change">
+          {{ formatPercent(calculationFor(index).expectedWinProbability) }} · {{ formatChange(calculationFor(index).displayChange) }}
+        </span>
+        <button type="button" class="remove" title="Einzel entfernen" @click="removeMatch(index)">×</button>
+      </div>
+      <p v-if="calculationError" class="error">{{ calculationError }}</p>
+    </section>
+
+    <section v-if="event" class="summary">
+      <span>Ausgangs-TTR: <strong>{{ event.ownTtrSnapshot }}</strong></span>
+      <span>Gesamtänderung: <strong :class="event.displayChange >= 0 ? 'positive' : 'negative'">{{ formatChange(event.displayChange) }}</strong></span>
+      <span>Voraussichtlicher TTR: <strong>{{ event.projectedTtr }}</strong></span>
+    </section>
+  </div>
+</template>
+
+<script>
+import { calculateTtrEvent } from '../services/ttrCalculator.mjs';
+import apiClient from '../apiClient.js';
+
+let nextMatchId = 1;
+
+export default {
+  name: 'TtrSimulatorDialog',
+  props: {
+    clubId: { type: [Number, String], default: null },
+  },
+  data() {
+    return {
+      ownTtr: 1300,
+      adjustmentConstant: 16,
+      selectedMemberId: '',
+      members: [],
+      membersLoading: false,
+      matches: [
+        { id: nextMatchId++, name: '', opponentTtr: 1300, result: 'win' },
+      ],
+    };
+  },
+  computed: {
+    membersWithTtr() {
+      return this.members.filter((member) => Number.isFinite(Number(member.ttr)));
+    },
+    calculationError() {
+      try {
+        calculateTtrEvent({ ownTtr: this.ownTtr, adjustmentConstant: this.adjustmentConstant, matches: this.matches });
+        return '';
+      } catch (error) {
+        return error.message;
+      }
+    },
+    event() {
+      try {
+        return calculateTtrEvent({ ownTtr: this.ownTtr, adjustmentConstant: this.adjustmentConstant, matches: this.matches });
+      } catch (_error) {
+        return null;
+      }
+    },
+  },
+  mounted() {
+    this.loadMembers();
+  },
+  methods: {
+    async loadMembers() {
+      if (!this.clubId) return;
+      this.membersLoading = true;
+      try {
+        const response = await apiClient.get(`/matches/${this.clubId}/players`);
+        this.members = Array.isArray(response.data) ? response.data : [];
+      } catch (_error) {
+        // The simulator remains fully usable with manual values if club data
+        // cannot be loaded (for example without the schedule permission).
+        this.members = [];
+      } finally {
+        this.membersLoading = false;
+      }
+    },
+    applySelectedMember() {
+      const member = this.members.find((entry) => String(entry.id) === this.selectedMemberId);
+      if (!member) return;
+      this.ownTtr = Number(member.ttr);
+      if (Number.isFinite(Number(member.ttrAdjustmentConstant))) {
+        this.adjustmentConstant = Number(member.ttrAdjustmentConstant);
+      }
+    },
+    addMatch() {
+      this.matches.push({ id: nextMatchId++, name: '', opponentTtr: this.ownTtr || 1300, result: 'win' });
+    },
+    removeMatch(index) {
+      if (this.matches.length > 1) this.matches.splice(index, 1);
+    },
+    calculationFor(index) {
+      return this.event?.calculations[index] || null;
+    },
+    formatPercent(value) {
+      return `Erwartung ${(value * 100).toFixed(1)} %`;
+    },
+    formatChange(value) {
+      return `${value > 0 ? '+' : ''}${value}`;
+    },
+  },
+};
+</script>
+
+<style scoped>
+.ttr-simulator { min-width: min(660px, 82vw); color: #243247; }
+.intro { margin-top: 0; color: #526174; }
+.form-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; margin: 18px 0; }
+label { display: grid; gap: 5px; font-weight: 650; font-size: .9rem; }
+input, select { min-height: 36px; border: 1px solid #cbd5e1; border-radius: 6px; padding: 6px 8px; font: inherit; }
+.section-heading { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
+.section-heading h4 { margin: 0; }
+.match-row { display: grid; grid-template-columns: minmax(120px, 1.2fr) minmax(100px, .7fr) 120px minmax(150px, 1fr) 32px; align-items: center; gap: 8px; margin: 8px 0; }
+.single-change { font-variant-numeric: tabular-nums; white-space: nowrap; }
+.remove { border: 0; background: transparent; color: #b42318; font-size: 1.4rem; cursor: pointer; }
+.summary { display: flex; gap: 20px; flex-wrap: wrap; margin-top: 22px; padding: 14px; border-radius: 8px; background: #edf7f1; font-variant-numeric: tabular-nums; }
+.positive { color: #167045; }.negative, .error { color: #b42318; }
+@media (max-width: 620px) { .ttr-simulator { min-width: 0; } .form-grid, .match-row { grid-template-columns: 1fr; } }
+</style>
diff --git a/frontend/src/components/schedule/ScheduleLayoutShell.vue b/frontend/src/components/schedule/ScheduleLayoutShell.vue
index 1f5dfa91..7603bb55 100755
--- a/frontend/src/components/schedule/ScheduleLayoutShell.vue
+++ b/frontend/src/components/schedule/ScheduleLayoutShell.vue
@@ -38,6 +38,14 @@
                     >
                         🧪 Spielbericht simulieren
                     </button>
+                    <button
+                        v-if="showScheduleActions"
+                        type="button"
+                        class="btn-secondary schedule-add-match-button"
+                        @click="$emit('open-ttr-simulator')"
+                    >
+                        TTR-Simulator
+                    </button>
                     <button v-if="showFriendlyActions" @click="$emit('open-friendly-match-modal')" class="btn-secondary">Freundschaftsspiel</button>
                     <button
                         v-if="showGalleryButton"
@@ -232,6 +240,8 @@ export default {
         'season-change',
         'open-import-modal',
         'open-manual-match-modal',
+        'open-match-report-simulator',
+        'open-ttr-simulator',
         'open-friendly-match-modal',
         'open-gallery-dialog',
         'update:team-search-query',
diff --git a/frontend/src/services/ttrCalculator.mjs b/frontend/src/services/ttrCalculator.mjs
new file mode 100644
index 00000000..01226197
--- /dev/null
+++ b/frontend/src/services/ttrCalculator.mjs
@@ -0,0 +1,80 @@
+/**
+ * Reusable calculation engine for the German TTR rating.
+ *
+ * A rating event (for example a team match) always uses the rating snapshot
+ * from before the event.  Therefore this module never mutates a player's TTR;
+ * callers pass the same snapshot into every single calculation and sum the
+ * raw changes with calculateTtrEvent().
+ */
+
+export const TTR_RATING_DIFFERENCE_DIVISOR = 150;
+
+function finiteNumber(value, name) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) throw new TypeError(`${name} muss eine endliche Zahl sein.`);
+  return number;
+}
+
+export function roundTtr(value) {
+  const number = finiteNumber(value, 'TTR-Änderung');
+  // "Rundung auf ganze Zahlen" must be symmetric for positive and negative
+  // values. Math.round(-0.5) would incorrectly return -0 in JavaScript.
+  return number < 0 ? -Math.round(Math.abs(number)) : Math.round(number);
+}
+
+export function calculateExpectedWinProbability(ownTtr, opponentTtr) {
+  const own = finiteNumber(ownTtr, 'Eigener TTR');
+  const opponent = finiteNumber(opponentTtr, 'Gegner-TTR');
+  return 1 / (1 + 10 ** ((opponent - own) / TTR_RATING_DIFFERENCE_DIVISOR));
+}
+
+/** Calculate the TTR effect of one single. result accepts win/loss or 1/0. */
+export function calculateTtrChange(ownTtr, opponentTtr, result, adjustmentConstant) {
+  const expectedWinProbability = calculateExpectedWinProbability(ownTtr, opponentTtr);
+  const adjustment = finiteNumber(adjustmentConstant, 'Änderungskonstante');
+  if (adjustment < 0) throw new RangeError('Die Änderungskonstante darf nicht negativ sein.');
+
+  const normalizedResult = result === 'win' || result === true || Number(result) === 1
+    ? 1
+    : result === 'loss' || result === false || Number(result) === 0
+      ? 0
+      : null;
+  if (normalizedResult === null) throw new TypeError('Ergebnis muss Sieg oder Niederlage sein.');
+
+  const rawChange = (normalizedResult - expectedWinProbability) * adjustment;
+  return {
+    result: normalizedResult,
+    expectedWinProbability,
+    rawChange,
+    displayChange: roundTtr(rawChange),
+  };
+}
+
+/**
+ * Calculate an entire event from immutable TTR snapshots.
+ * Each entry needs opponentTtr and result and may override adjustmentConstant.
+ */
+export function calculateTtrEvent({ ownTtr, adjustmentConstant, matches }) {
+  if (!Array.isArray(matches)) throw new TypeError('matches muss ein Array sein.');
+  const ownSnapshot = finiteNumber(ownTtr, 'Eigener TTR');
+  const defaultAdjustment = finiteNumber(adjustmentConstant, 'Änderungskonstante');
+  const calculations = matches.map((match) => ({
+    ...match,
+    ownTtrSnapshot: ownSnapshot,
+    ...calculateTtrChange(
+      ownSnapshot,
+      match.opponentTtr,
+      match.result,
+      match.adjustmentConstant ?? defaultAdjustment,
+    ),
+  }));
+  const rawChange = calculations.reduce((total, match) => total + match.rawChange, 0);
+  const displayChange = roundTtr(rawChange);
+  return {
+    ownTtrSnapshot: ownSnapshot,
+    calculations,
+    rawChange,
+    displayChange,
+    projectedTtr: ownSnapshot + displayChange,
+  };
+}
diff --git a/frontend/src/views/ScheduleView.vue b/frontend/src/views/ScheduleView.vue
index c87cc6b7..868d4221 100755
--- a/frontend/src/views/ScheduleView.vue
+++ b/frontend/src/views/ScheduleView.vue
@@ -32,6 +32,7 @@
             @open-import-modal="openImportModal"
             @open-manual-match-modal="openManualMatchDialog"
             @open-match-report-simulator="openMatchReportSimulator"
+            @open-ttr-simulator="openTtrSimulator"
             @open-friendly-match-modal="openFriendlyMatchDialog"
             @open-gallery-dialog="openGalleryDialog"
             @update:team-search-query="teamSearchQuery = $event"
@@ -2953,6 +2954,14 @@ export default {
                 }
             });
         },
+
+        openTtrSimulator() {
+            this.openDialog({
+                title: 'TTR-Simulator',
+                component: 'TtrSimulatorDialog',
+                props: { clubId: this.currentClub }
+            });
+        },
         
         async loadLeagueTable(leagueId) {
             try {
diff --git a/frontend/tests/ttrCalculator.test.mjs b/frontend/tests/ttrCalculator.test.mjs
new file mode 100644
index 00000000..d84925f7
--- /dev/null
+++ b/frontend/tests/ttrCalculator.test.mjs
@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  calculateExpectedWinProbability,
+  calculateTtrChange,
+  calculateTtrEvent,
+  roundTtr,
+} from '../src/services/ttrCalculator.mjs';
+
+test('equal ratings have a 50 percent expected win probability', () => {
+  assert.equal(calculateExpectedWinProbability(1500, 1500), 0.5);
+  assert.equal(calculateTtrChange(1500, 1500, 'win', 16).displayChange, 8);
+  assert.equal(calculateTtrChange(1500, 1500, 'loss', 16).displayChange, -8);
+});
+
+test('a win against a stronger player gains more than a win against a weaker player', () => {
+  const strong = calculateTtrChange(1318, 1429, 'win', 16);
+  const weak = calculateTtrChange(1318, 1180, 'win', 16);
+  assert.ok(strong.rawChange > weak.rawChange);
+  assert.ok(calculateTtrChange(1318, 1429, 'loss', 16).rawChange > calculateTtrChange(1318, 1180, 'loss', 16).rawChange);
+});
+
+test('an event uses one immutable snapshot and rounds only the total', () => {
+  const event = calculateTtrEvent({
+    ownTtr: 1318,
+    adjustmentConstant: 16,
+    matches: [
+      { opponentTtr: 1382, result: 'win' },
+      { opponentTtr: 1429, result: 'win' },
+    ],
+  });
+  assert.equal(event.calculations[0].ownTtrSnapshot, 1318);
+  assert.equal(event.ownTtrSnapshot, 1318);
+  assert.equal(event.displayChange, 25);
+  assert.equal(event.projectedTtr, 1343);
+  assert.equal(event.displayChange, roundTtr(event.calculations[0].rawChange + event.calculations[1].rawChange));
+  assert.equal(event.projectedTtr, 1318 + event.displayChange);
+});
+
+test('the adjustment constant is player-specific input', () => {
+  const with16 = calculateTtrChange(1500, 1500, 'win', 16).rawChange;
+  const with8 = calculateTtrChange(1500, 1500, 'win', 8).rawChange;
+  assert.equal(with16, with8 * 2);
+});
diff --git a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/AppRoot.kt b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/AppRoot.kt
index f28b17d6..02526366 100755
--- a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/AppRoot.kt
+++ b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/AppRoot.kt
@@ -5259,20 +5259,36 @@ private fun MembersScreen(
                     }
                     .sortedWith(
                         Comparator { a, b ->
-                            val base = when (selectedSort) {
-                                "ttr" -> (a.ttr ?: Int.MIN_VALUE).compareTo(b.ttr ?: Int.MIN_VALUE)
-                                "qttr" -> (a.qttr ?: Int.MIN_VALUE).compareTo(b.qttr ?: Int.MIN_VALUE)
+                            val compareNames = {
+                                val byLast = a.lastName.lowercase().compareTo(b.lastName.lowercase())
+                                if (byLast != 0) byLast else a.firstName.lowercase().compareTo(b.firstName.lowercase())
+                            }
+                            if (selectedSort == "ttr" || selectedSort == "qttr") {
+                                val ratingA = if (selectedSort == "ttr") a.ttr else a.qttr
+                                val ratingB = if (selectedSort == "ttr") b.ttr else b.qttr
+                                // Wie in der Web-App: nicht bewertete Mitglieder stehen
+                                // unabhängig von der Sortierrichtung immer am Listenende.
+                                when {
+                                    ratingA == null && ratingB != null -> 1
+                                    ratingA != null && ratingB == null -> -1
+                                    ratingA == null && ratingB == null -> compareNames()
+                                    else -> {
+                                        val direction = if (sortAscending) 1 else -1
+                                        val ratingDiff = ratingA!!.compareTo(ratingB!!) * direction
+                                        if (ratingDiff != 0) ratingDiff else compareNames()
+                                    }
+                                }
+                            } else {
+                                val base = when (selectedSort) {
                                 "lastTraining" -> a.lastTraining.orEmpty().compareTo(b.lastTraining.orEmpty())
                                 "birthDate" -> a.birthDate.orEmpty().compareTo(b.birthDate.orEmpty())
                                 "firstName" -> a.firstName.lowercase().compareTo(b.firstName.lowercase())
                                 "age" -> (memberAgeYears(a) ?: Int.MIN_VALUE).compareTo(memberAgeYears(b) ?: Int.MIN_VALUE)
                                 "openTasks" -> memberOpenTasksCount(a, qualityReq).compareTo(memberOpenTasksCount(b, qualityReq))
-                                else -> {
-                                    val byLast = a.lastName.lowercase().compareTo(b.lastName.lowercase())
-                                    if (byLast != 0) byLast else a.firstName.lowercase().compareTo(b.firstName.lowercase())
-                                }
+                                else -> compareNames()
+                            }
+                                if (sortAscending) base else -base
                             }
-                            if (sortAscending) base else -base
                         },
                     )
             }
diff --git a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamEditorLineupLogic.kt b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamEditorLineupLogic.kt
index 96962831..824f5551 100755
--- a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamEditorLineupLogic.kt
+++ b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamEditorLineupLogic.kt
@@ -128,6 +128,15 @@ internal object TeamEditorLineupLogic {
         return q.toString()
     }
 
+    /** QTTR-Reihenfolge für Meldungen: bewertete Spieler zuerst, danach Name. */
+    fun compareForLineup(a: Member, b: Member): Int {
+        val ratingDiff = lineupRatingValue(b).compareTo(lineupRatingValue(a))
+        if (ratingDiff != 0) return ratingDiff
+        val byLast = a.lastName.lowercase().compareTo(b.lastName.lowercase())
+        if (byLast != 0) return byLast
+        return a.firstName.lowercase().compareTo(b.firstName.lowercase())
+    }
+
     fun eligibilityLabel(member: Member, teamAgeGroup: String, seasonLabel: String): String {
         val mag = memberAgeGroupCode(member, seasonLabel)
         if (teamAgeGroup != "adult" || mag == "adult") return "OK"
@@ -194,11 +203,7 @@ internal object TeamEditorLineupLogic {
             byCode.getOrPut(code) { mutableListOf() }.add(row)
         }
         for (list in byCode.values) {
-            list.sortWith(
-                compareByDescending<MemberDisplay> { lineupRatingValue(it.member) }
-                    .thenBy { it.member.lastName.lowercase() }
-                    .thenBy { it.member.firstName.lowercase() },
-            )
+            list.sortWith { a, b -> compareForLineup(a.member, b.member) }
         }
         return groupOrder.mapNotNull { code ->
             val rows = byCode[code] ?: return@mapNotNull null
diff --git a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamPlanningScreen.kt b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamPlanningScreen.kt
index 60a06a20..46bc108a 100755
--- a/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamPlanningScreen.kt
+++ b/mobile-app/composeApp/src/androidMain/kotlin/de/tsschulz/tt_tagebuch/app/ui/TeamPlanningScreen.kt
@@ -176,7 +176,7 @@ internal fun TeamPlanningScreen(
                 if (q.isEmpty()) true
                 else "${it.firstName} ${it.lastName}".lowercase().contains(q)
             }
-            .sortedWith(compareBy({ it.lastName.lowercase() }, { it.firstName.lowercase() }))
+            .sortedWith(TeamEditorLineupLogic::compareForLineup)
     }
 
     val assignedIds = remember(assignments) { assignments.map { it.memberId }.toSet() }
@@ -189,7 +189,7 @@ internal fun TeamPlanningScreen(
         members.filter { m ->
             m.active && m.testMembership != true && m.id !in interestedIds &&
                 (q.isEmpty() || "${m.firstName} ${m.lastName}".lowercase().contains(q))
-        }.sortedWith(compareBy({ it.lastName.lowercase() }, { it.firstName.lowercase() }))
+        }.sortedWith(TeamEditorLineupLogic::compareForLineup)
     }
 
     fun persistTeam(teamId: Int, nextAssignments: List<PlanningAssignment>, onDone: () -> Unit = {}) {
@@ -281,6 +281,10 @@ internal fun TeamPlanningScreen(
                     Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
                         Column(Modifier.weight(1f)) {
                             Text("${m.firstName} ${m.lastName}", fontWeight = FontWeight.Medium)
+                            Text(
+                                "QTTR ${TeamEditorLineupLogic.lineupRatingLabel(m)}",
+                                style = MaterialTheme.typography.caption,
+                            )
                         }
                         if (canWrite) {
                             var addMenu by remember(key1 = m.id) { mutableStateOf(false) }
@@ -344,10 +348,12 @@ internal fun TeamPlanningScreen(
                                 enabled = canWrite && !markingInterest,
                                 modifier = Modifier.fillMaxWidth(),
                             ) {
-                                Text(
-                                    addInterestMemberId?.let { id ->
-                                        membersById[id]?.let { "${it.firstName} ${it.lastName}" }
-                                    } ?: t("teamManagement.selectMember", "Mitglied wählen"),
+                                    Text(
+                                        addInterestMemberId?.let { id ->
+                                            membersById[id]?.let {
+                                                "${it.firstName} ${it.lastName} (QTTR ${TeamEditorLineupLogic.lineupRatingLabel(it)})"
+                                            }
+                                        } ?: t("teamManagement.selectMember", "Mitglied wählen"),
                                 )
                             }
                             DropdownMenu(expanded = addInterestMenu, onDismissRequest = { addInterestMenu = false }) {
@@ -357,7 +363,7 @@ internal fun TeamPlanningScreen(
                                             addInterestMemberId = m.id
                                             addInterestMenu = false
                                         },
-                                    ) { Text("${m.firstName} ${m.lastName}") }
+                                    ) { Text("${m.firstName} ${m.lastName} (QTTR ${TeamEditorLineupLogic.lineupRatingLabel(m)})") }
                                 }
                             }
                         }
@@ -604,7 +610,7 @@ private fun CardTeamPlanningBlock(
         Text(t("teamManagement.selectedLineup", "Meldung"), fontWeight = FontWeight.Medium)
         ordered.forEachIndexed { index, m ->
             Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
-                Text("${index + 1}. ${m.firstName} ${m.lastName}")
+                Text("${index + 1}. ${m.firstName} ${m.lastName} (${TeamEditorLineupLogic.lineupRatingLabel(m)})")
                 if (canWrite) {
                     Row {
                         TextButton(onClick = { onMoveInTeam(m.id, -1) }, enabled = index > 0) { Text("↑") }
@@ -635,7 +641,7 @@ private fun CardTeamPlanningBlock(
                                     onPersistLineup(next)
                                 }
                             },
-                        ) { Text("${m.firstName} ${m.lastName}") }
+                        ) { Text("${m.firstName} ${m.lastName} (${TeamEditorLineupLogic.lineupRatingLabel(m)})") }
                     }
                 }
             }