Die Mathematik hinter allem: Growth Marketing Mathematik erklärt

Psychologie macht neugierig. Daten bringen Funding. Jedes Prinzip in dieser Serie muss letztendlich gemessen, modelliert und bewiesen werden. Hier kommt die Mathematik ins Spiel. Dieser Beitrag ist das finale Kapitel: die quantitativen Grundlagen, die Bauchgefühl Marketer von datengetriebenen Growth Praktikern unterscheiden.

LTV:CAC Ratio: Das Fundament der Unit Economics

Die einfache Erklärung

Stell dir vor, du betreibst einen Limonadenstand. Du gibst 10€ für Flyer aus, um einen Kunden zu gewinnen. Dieser Kunde kauft im nächsten Jahr Limonade für insgesamt 30€ Profit. Dein LTV:CAC Ratio ist 3:1. Du hast 10€ ausgegeben, um 30€ zu bekommen. Guter Deal.

Jetzt stell dir vor, du gibst 10€ für Flyer aus, aber der Kunde kauft nur Limonade für 8€. Dein LTV:CAC Ratio ist 0.8:1. Du zahlst buchstäblich drauf, um Geld zu verlieren. Jeder Kunde, den du gewinnst, macht dich ärmer.

LTV (Lifetime Value): Der gesamte Profit, den ein Kunde über seine gesamte Beziehung mit dir generiert.

CAC (Customer Acquisition Cost): Was du ausgegeben hast, um diesen Kunden zu gewinnen.

LTV:CAC Ratio: Wie viele Euro Wert du für jeden Euro Akquisekosten zurückbekommst.

Die Formel

Die grundlegende LTV Formel:

$LTV = ARPU \times Bruttomarge \times Durchschnittliche\ Kundenlebensdauer$

Wobei:

• ARPU = Average Revenue Per User (monatlich oder jährlich)
• Bruttomarge = Umsatz minus Herstellungskosten, als Prozentsatz
• Durchschnittliche Kundenlebensdauer = Wie lange Kunden bleiben

Für Abo Geschäfte mit monatlichem Churn gibt es eine elegantere Formel:

$LTV = \frac{ARPU \times Bruttomarge}{Churn\ Rate}$

Das funktioniert, weil bei einer monatlichen Churn Rate von 5% die durchschnittliche Kundenlebensdauer 1/0.05 = 20 Monate beträgt.

Die Benchmarks

Ratio	Interpretation
< 1:1	Du verlierst Geld bei jedem Kunden. Stopp.
1:1 bis 2:1	Marginal. Vielleicht Break-even. Hohes Risiko.
3:1	Das Minimum für gesunde Einheiten. Industriestandard.
5:1+	Starke Unit Economics. Erwäge mehr Akquise Invest.
10:1+	Entweder unterinvestiert in Growth, oder CAC Messung ist falsch.

Python Implementierung

import numpy as np

def calculate_ltv_simple(arpu_monthly, gross_margin, churn_rate_monthly):
    """
    Berechne LTV mit der Standard Abo Formel.
    """
    if churn_rate_monthly <= 0:
        raise ValueError("Churn Rate muss positiv sein")
    
    avg_lifespan_months = 1 / churn_rate_monthly
    ltv = arpu_monthly * gross_margin * avg_lifespan_months
    
    return ltv

def calculate_ltv_cac_ratio(ltv, cac):
    """
    Berechne LTV:CAC Ratio mit Interpretation.
    """
    ratio = ltv / cac
    
    if ratio < 1:
        interpretation = "KRITISCH: Verlust bei jedem Kunden"
    elif ratio < 2:
        interpretation = "WARNUNG: Marginale Unit Economics"
    elif ratio < 3:
        interpretation = "VORSICHT: Unter Zielwert"
    elif ratio < 5:
        interpretation = "GESUND: Gute Unit Economics"
    else:
        interpretation = "STARK: Erwäge mehr Akquise Spend"
    
    return ratio, interpretation

# Beispiel: SaaS Geschäft
arpu = 99  # €99/Monat
gross_margin = 0.80  # 80% Marge (Software)
monthly_churn = 0.03  # 3% monatlicher Churn
cac = 400  # €400 um einen Kunden zu gewinnen

ltv = calculate_ltv_simple(arpu, gross_margin, monthly_churn)
ratio, interpretation = calculate_ltv_cac_ratio(ltv, cac)

print(f"LTV: €{ltv:,.2f}")
print(f"LTV:CAC Ratio: {ratio:.1f}:1")
print(f"{interpretation}")

Payback Period: Wann bekommst du dein Geld zurück?

Die einfache Erklärung

LTV:CAC sagt dir, ob sich die Investition lohnt. Payback Period sagt dir, wie lange du auf die Rendite warten musst.

Stell dir vor, du gibst 1.000€ aus, um einen Kunden zu gewinnen, der dir 100€/Monat zahlt. Deine Payback Period ist 10 Monate. Für 10 Monate ist dieser Kunde unter Wasser (du hast deine Investition noch nicht zurück). Nach Monat 10 wird er profitabel.

Warum ist das wichtig? Cashflow. Wenn deine Payback Period 24 Monate ist, musst du 24 Monate Akquisekosten finanzieren, bevor du Rückflüsse siehst. Das erfordert Kapital.

Die Formel

$Payback\ Period = \frac{CAC}{ARPU \times Bruttomarge}$

Die Benchmarks

Business Typ	Ziel Payback Period
E-Commerce	< 6 Monate (idealerweise erster Kauf)
SaaS (SMB)	< 12 Monate
SaaS (Enterprise)	< 18 Monate
Marktplatz	< 6 Monate pro Seite

Python Implementierung

import numpy as np

def payback_analysis(cac, arpu_monthly, gross_margin, churn_rate_monthly):
    """
    Vollständige Payback Analyse inklusive Überlebenswahrscheinlichkeit.
    
    Die Erkenntnis: Manche Kunden churnen vor dem Payback.
    Das müssen wir berücksichtigen.
    """
    
    simple_payback = cac / (arpu_monthly * gross_margin)
    
    # Wahrscheinlichkeit bis zum Payback zu überleben
    survival_prob = (1 - churn_rate_monthly) ** simple_payback
    
    # Erwarteter Payback unter Berücksichtigung von Churn
    monthly_contribution = arpu_monthly * gross_margin
    
    # Simuliere erwarteten kumulativen Beitrag
    months = np.arange(1, 61)  # 5 Jahre
    survival = (1 - churn_rate_monthly) ** months
    cumulative_contribution = np.cumsum(monthly_contribution * survival)
    
    # Finde wann kumulativer Beitrag CAC übersteigt
    if cumulative_contribution[-1] < cac:
        expected_payback = float('inf')
    else:
        expected_payback = months[cumulative_contribution >= cac][0]
    
    return {
        'simple_payback': simple_payback,
        'survival_to_payback': survival_prob,
        'expected_payback': expected_payback
    }

results = payback_analysis(500, 80, 0.75, 0.04)
print(f"Einfacher Payback: {results['simple_payback']:.1f} Monate")
print(f"Überlebenswahrscheinlichkeit bis Payback: {results['survival_to_payback']*100:.1f}%")

Kohortenanalyse: Hör auf, alles zu mitteln

Die einfache Erklärung

Stell dir vor, du hast 1.000 Kunden. Dein durchschnittlicher monatlicher Umsatz pro Kunde ist 50€. Toll, oder?

Aber was, wenn Kunden aus dem Januar durchschnittlich 80€/Monat bringen, während Kunden aus dem Juni nur 20€/Monat bringen? Dein "Durchschnitt" versteckt ein kritisches Problem: Deine Akquisequalität sinkt. Oder dein Produkt wird für neue Nutzer schlechter. Oder du hast Kanäle gewechselt und der neue Kanal bringt schlechtere Kunden.

Kohortenanalyse gruppiert Nutzer nach dem Zeitpunkt ihrer Akquise und verfolgt sie über die Zeit. Muster, die auf Aggregatebene unsichtbar sind, werden offensichtlich.

Python Implementierung

import pandas as pd
import numpy as np

def create_cohort_retention_table(df, user_col, date_col, cohort_col):
    """
    Erstelle eine Kohorten Retention Tabelle aus Transaktions/Aktivitätsdaten.
    """
    
    df['activity_month'] = pd.to_datetime(df[date_col]).dt.to_period('M')
    df['cohort_month'] = pd.to_datetime(df[cohort_col]).dt.to_period('M')
    
    df['months_since_acquisition'] = (
        df['activity_month'] - df['cohort_month']
    ).apply(lambda x: x.n if pd.notna(x) else 0)
    
    # Erstelle Kohorten Tabelle
    cohort_data = df.groupby(
        ['cohort_month', 'months_since_acquisition']
    )[user_col].nunique().reset_index()
    cohort_data.columns = ['cohort_month', 'months_since', 'users']
    
    # Pivot für Retention Matrix
    cohort_pivot = cohort_data.pivot(
        index='cohort_month', 
        columns='months_since', 
        values='users'
    )
    
    # Konvertiere zu Prozenten (relativ zu Monat 0)
    cohort_sizes = cohort_pivot[0]
    cohort_retention = cohort_pivot.div(cohort_sizes, axis=0) * 100
    
    return cohort_retention, cohort_sizes

print("Kohortenanalyse Schlüssel Erkenntnisse:")
print("  • Schaue VERTIKAL: Wie vergleicht sich Monat 3 Retention über Kohorten?")
print("  • Schaue HORIZONTAL: Wie verfällt Retention für eine einzelne Kohorte?")
print("  • Spätere Kohorten mit schlechterer Retention = Warnsignal!")

Survival Analysis: Ein besserer Weg, Churn zu modellieren

Die einfache Erklärung

Traditionelle Churn Metriken ("5% der Kunden sind letzten Monat abgewandert") haben ein Problem: Sie behandeln alle Kunden gleich, unabhängig davon, wie lange sie schon bei dir sind.

Aber ein Kunde, der seit 3 Jahren bei dir ist, churnt anders als ein Kunde, der letzte Woche beigetreten ist. Survival Analysis, entlehnt aus der Biostatistik (wo sie zur Modellierung des Patientenüberlebens verwendet wird), berücksichtigt das.

Die Schlüsselkonzepte

Survival Funktion S(t): Die Wahrscheinlichkeit, bis zum Zeitpunkt t zu überleben (nicht zu churnen).

$S(t) = P(T > t)$

Hazard Funktion h(t): Das momentane Churn Risiko zum Zeitpunkt t, gegeben Überleben bis t.

$h(t) = \lim_{\Delta t \to 0} \frac{P(t \leq T < t + \Delta t | T \geq t)}{\Delta t}$

Auf Deutsch: Die Hazard Rate ist das "Churn Risiko" in jedem Moment, unter Berücksichtigung wie lange der Kunde bereits überlebt hat.

Kaplan-Meier Schätzer: Ein nicht-parametrischer Weg, die Survival Funktion aus Daten zu schätzen.

$\hat{S}(t) = \prod_{t_i \leq t} \left(1 - \frac{d_i}{n_i}\right)$

Wobei:

• $d_i$ = Anzahl der Churns zum Zeitpunkt $t_i$
• $n_i$ = Anzahl der Kunden noch at risk zum Zeitpunkt $t_i$

Python Implementierung

import numpy as np
import pandas as pd

def kaplan_meier_estimator(durations, observed):
    """
    Berechne Kaplan-Meier Survival Schätzungen.
    
    Parameters:
    -----------
    durations : array-like
        Zeit bis Event (Churn) oder Zensierung für jeden Kunden
    observed : array-like
        1 wenn der Kunde gechurnt ist, 0 wenn noch aktiv (zensiert)
    """
    
    data = pd.DataFrame({
        'duration': durations,
        'observed': observed
    }).sort_values('duration')
    
    event_times = sorted(data[data['observed'] == 1]['duration'].unique())
    
    results = []
    survival_prob = 1.0
    
    for t in event_times:
        d_t = len(data[(data['duration'] == t) & (data['observed'] == 1)])
        n_t = len(data[data['duration'] >= t])
        
        if n_t > 0:
            survival_prob = survival_prob * (1 - d_t / n_t)
        
        results.append({
            'time': t,
            'at_risk': n_t,
            'churned': d_t,
            'survival_prob': survival_prob
        })
    
    return pd.DataFrame(results)

print("Interpretation der Survival Kurve:")
print("  • Kurve fällt steil früh = hoher früher Churn")
print("  • Kurve flacht später ab = Überlebende werden loyal")
print("  • Vergleiche Kurven über Kohorten um Probleme zu erkennen")

Bayesian A/B Testing: Wahrscheinlichkeit statt P-Werte

Die einfache Erklärung

Traditionelles (frequentistisches) A/B Testing fragt: "Wenn es wirklich keinen Unterschied zwischen A und B gibt, wie wahrscheinlich ist es, dass ich so extreme Daten sehe?"

Bayesian A/B Testing fragt eine intuitivere Frage: "Gegeben die Daten, die ich gesehen habe, wie hoch ist die Wahrscheinlichkeit, dass B besser ist als A?"

Für einen Marketer ist die Bayesian Frage viel nützlicher. Du willst wissen: "Wenn ich Variante B ausrolle, wie hoch ist die Wahrscheinlichkeit, dass ich die richtige Entscheidung treffe?"

Warum Bayesian besser ist für Low-Traffic Seiten

1. Keine vorbestimmte Stichprobengröße nötig. Frequentistische Tests erfordern, dass du die Stichprobengröße vorher berechnest und wartest. Bayesian erlaubt dir jederzeit nachzuschauen.

2. Intuitive Interpretation. "87% Wahrscheinlichkeit, dass B besser ist" ist leichter zu handeln als "p = 0.034".

3. Entscheidungsfokussiert. Du kannst den erwarteten Verlust bei falscher Variantenwahl berechnen.

Die Formel

Bayes Theorem:

$P(\theta | data) = \frac{P(data | \theta) \times P(\theta)}{P(data)}$

In Worten: Posterior = (Likelihood × Prior) / Evidenz

Python Implementierung

import numpy as np

def bayesian_ab_test(visitors_a, conversions_a, visitors_b, conversions_b,
                     prior_alpha=1, prior_beta=1, n_simulations=100000):
    """
    Bayesian A/B Test für Conversion Rates.
    
    Verwendet Beta Verteilung als konjugierten Prior für binomiale Likelihood.
    Beta(1,1) ist uniformer Prior (uninformativ).
    """
    
    # Posterior Parameter
    alpha_a = prior_alpha + conversions_a
    beta_a = prior_beta + (visitors_a - conversions_a)
    
    alpha_b = prior_alpha + conversions_b
    beta_b = prior_beta + (visitors_b - conversions_b)
    
    # Sample aus Posteriors
    samples_a = np.random.beta(alpha_a, beta_a, n_simulations)
    samples_b = np.random.beta(alpha_b, beta_b, n_simulations)
    
    # Wahrscheinlichkeit B > A
    prob_b_better = np.mean(samples_b > samples_a)
    
    # Erwarteter Uplift
    uplift_samples = (samples_b - samples_a) / samples_a
    expected_uplift = np.mean(uplift_samples)
    
    # Risiko: Erwarteter Verlust wenn wir B wählen aber A besser ist
    loss_if_choose_b = np.mean(np.maximum(samples_a - samples_b, 0))
    
    return {
        'prob_b_better': prob_b_better,
        'expected_uplift': expected_uplift,
        'expected_loss_if_choose_b': loss_if_choose_b
    }

# Beispiel
results = bayesian_ab_test(1200, 48, 1180, 59)

print(f"Wahrscheinlichkeit B > A: {results['prob_b_better']*100:.1f}%")
print(f"Erwarteter Uplift: {results['expected_uplift']*100:+.1f}%")
print(f"Erwarteter Verlust wenn B gewählt wird: {results['expected_loss_if_choose_b']*100:.3f}%")

Multi-Armed Bandit: Adaptives Testing

Die einfache Erklärung

A/B Testing hat ein Problem: Opportunitätskosten. Während du testest, geht die Hälfte deines Traffics an die schlechtere Variante. Wenn der Test Wochen läuft, sind das viele verlorene Conversions.

Multi-Armed Bandits lösen das, indem sie Traffic während des Tests zu gewinnenden Varianten verschieben. Wenn sich Evidenz ansammelt, dass B besser ist, geht mehr Traffic zu B. Du "exploitest" was du lernst, während du noch "explorierst" um mehr Daten zu sammeln.

Der Name kommt von Spielautomaten ("einarmige Banditen"). Stell dir vor, du hast 3 Spielautomaten mit unbekannten Auszahlungsraten. Wie maximierst du deine Gewinne? Du musst das Ausprobieren neuer Automaten (Exploration) mit dem Spielen des besten, den du gefunden hast (Exploitation) balancieren.

Der Algorithmus: Thompson Sampling

1. Für jede Variante, pflege eine Beta Verteilung über ihre Conversion Rate.
2. Um einen Nutzer zuzuweisen, sample aus jeder Verteilung.
3. Weise den Nutzer der Variante mit dem höchsten Sample zu.
4. Update die Verteilungen basierend auf dem Ergebnis.

Python Implementierung

import numpy as np

class ThompsonSamplingBandit:
    """
    Multi-Armed Bandit mit Thompson Sampling.
    """
    
    def __init__(self, n_variants):
        self.n_variants = n_variants
        self.alpha = np.ones(n_variants)  # Erfolge + 1
        self.beta = np.ones(n_variants)   # Misserfolge + 1
        self.total_visitors = np.zeros(n_variants)
        self.total_conversions = np.zeros(n_variants)
    
    def select_variant(self):
        samples = np.random.beta(self.alpha, self.beta)
        return np.argmax(samples)
    
    def update(self, variant, converted):
        self.total_visitors[variant] += 1
        if converted:
            self.alpha[variant] += 1
            self.total_conversions[variant] += 1
        else:
            self.beta[variant] += 1

print("Thompson Sampling Vorteil:")
print("  Bandit verschiebt Traffic zu gewinnenden Varianten während des Tests")
print("  Das reduziert Opportunitätskosten beim Lernen")

Marketing Mix Modelling vs Attribution

Die einfache Erklärung

Attribution fragt: "Welcher Touchpoint bekommt den Credit für diese Conversion?"

Marketing Mix Modelling (MMM) fragt: "Wie viel hat jeder Kanal zu den Gesamtconversions beigetragen?"

Sie lösen verschiedene Probleme.

Attribution ist bottom-up: Verfolge einzelne Nutzer, gib Touchpoints Credit. MMM ist top-down: Modelliere aggregierte Daten, schätze Kanalbeitrag via Regression.

Mit sterbenden Cookies und strengeren Datenschutzregeln wird Attribution schwieriger. MMM erlebt eine Renaissance, weil es kein User-Level Tracking erfordert.

Attribution Modelle

Modell	Logik
Last-Touch	100% Credit an letzten Touchpoint
First-Touch	100% Credit an ersten Touchpoint
Linear	Gleicher Credit an alle Touchpoints
Time-Decay	Mehr Credit an neuere Touchpoints
Position-Based	40% First, 40% Last, 20% Mitte

Python Implementierung

import numpy as np
import pandas as pd

def simple_marketing_mix_model(data):
    """
    Vereinfachtes Marketing Mix Model mit linearer Regression.
    
    In der Praxis enthält MMM:
    - Adstock (Carryover Effekte)
    - Sättigungskurven (abnehmende Erträge)
    - Saisonalitätskontrollen
    - Externe Faktoren (Wirtschaft, Wetter, etc.)
    """
    
    X = data[['tv_spend', 'digital_spend', 'social_spend', 'print_spend']].values
    y = data['revenue'].values
    
    # Intercept hinzufügen
    X_with_intercept = np.column_stack([np.ones(len(X)), X])
    
    # OLS Regression
    beta = np.linalg.lstsq(X_with_intercept, y, rcond=None)[0]
    
    channels = ['TV', 'Digital', 'Social', 'Print']
    
    print("MMM Ergebnisse (ROI pro €1 Spend):")
    for i, channel in enumerate(channels):
        print(f"  {channel}: €{beta[i+1]:.2f}/€1")
    
    return beta

print("MMM vs Attribution:")
print("  Attribution: Bottom-up, User-Level, Touchpoint Credit")
print("  MMM: Top-down, Aggregat, Kanalbeitrag via Regression")
print("  Beide sind nützlich; MMM funktioniert ohne Cookies")

Power Law Verteilungen: Der Wal Effekt

Die einfache Erklärung

Die meisten Business Metriken sind nicht normalverteilt. Kundenwert folgt insbesondere einem Power Law: Eine kleine Anzahl von Kunden treibt einen überproportionalen Anteil des Umsatzes.

Das berühmte Beispiel: 1% der Kunden treiben oft 50% des Umsatzes. Das hat tiefgreifende Implikationen für Akquise, Retention und Produktstrategie. Dein "durchschnittlicher Kunde" ist eine statistische Fiktion.

Die Mathematik

Eine Power Law Verteilung hat die Form:

$P(X > x) \propto x^{-\alpha}$

Die Wahrscheinlichkeit von Werten größer als x nimmt polynomiell ab, nicht exponentiell. Das bedeutet, extreme Werte sind viel wahrscheinlicher als bei einer Normalverteilung.

Python Implementierung

import numpy as np

def analyse_customer_value_distribution(values):
    """
    Analysiere Kundenwertverteilung auf Power Law Charakteristiken.
    """
    
    values = np.array(values)
    total_value = np.sum(values)
    
    sorted_values = np.sort(values)[::-1]
    cumulative_value = np.cumsum(sorted_values)
    cumulative_pct = cumulative_value / total_value
    
    n_customers = len(values)
    
    # Was % der Kunden treiben 50% des Wertes?
    idx_50 = np.searchsorted(cumulative_pct, 0.5)
    pct_customers_for_50 = (idx_50 + 1) / n_customers
    
    # Was % des Wertes kommt von Top 1%?
    top_1_pct_idx = max(1, int(n_customers * 0.01))
    value_from_top_1 = cumulative_pct[top_1_pct_idx - 1]
    
    return {
        'pct_customers_for_50_value': pct_customers_for_50,
        'value_from_top_1_pct': value_from_top_1
    }

print("Strategische Implikationen:")
print("  • Dein 'durchschnittlicher Kunde' ist eine statistische Fiktion")
print("  • Wale brauchen andere Behandlung als der Long Tail")
print("  • Retention der Top 1% ist wichtiger als Akquise von Durchschnittskunden")

Preiselastizität: Wie Nachfrage auf Preise reagiert

Die einfache Erklärung

Wenn du die Preise um 10% erhöhst, verlierst du 5% der Kunden? 20%? 50%? Die Antwort bestimmt, ob die Preiserhöhung dir Geld bringt oder kostet.

Preiselastizität der Nachfrage quantifiziert diese Beziehung.

Elastische Nachfrage (|ε| > 1): Nachfrage ändert sich mehr als proportional zum Preis. 10% Preiserhöhung verursacht >10% Nachfragerückgang. Gesamtumsatz fällt.

Unelastische Nachfrage (|ε| < 1): Nachfrage ändert sich weniger als proportional. 10% Preiserhöhung verursacht <10% Nachfragerückgang. Gesamtumsatz steigt.

Die Formel

$\varepsilon = \frac{\% \Delta Q}{\% \Delta P} = \frac{\partial Q / Q}{\partial P / P}$

Van Westendorp Preissensitivitätsmeter

Ein praktisches Tool um akzeptable Preisspannen zu finden. Fragt 4 Fragen:

1. Zu billig: Unter welchem Preis würdest du die Qualität anzweifeln?
2. Günstig: Unter welchem Preis wäre es ein guter Deal?
3. Teuer: Ab welchem Preis würdest du zögern?
4. Zu teuer: Ab welchem Preis würdest du nicht kaufen?

Die Schnittpunkte der Kurven ergeben:

• PMC (Point of Marginal Cheapness): Untergrenze
• PME (Point of Marginal Expensiveness): Obergrenze
• OPP (Optimal Price Point): Optimaler Preis
• IPP (Indifference Price Point): Fairer Preis

import numpy as np
import pandas as pd

def van_westendorp_analysis(survey_data):
    """
    Van Westendorp Preissensitivitätsmeter.
    """
    
    prices = np.linspace(10, 200, 1000)
    
    too_cheap_cum = np.array([np.mean(survey_data['too_cheap'] >= p) for p in prices])
    too_expensive_cum = np.array([np.mean(survey_data['too_expensive'] <= p) for p in prices])
    
    # Finde Schnittpunkt
    def find_intersection(curve1, curve2, prices):
        diff = curve1 - curve2
        idx = np.argmin(np.abs(diff))
        return prices[idx]
    
    opp = find_intersection(too_cheap_cum, too_expensive_cum, prices)
    
    return {'optimal_price_point': opp}

print("Van Westendorp Praktische Anwendung:")
print("  1. Befrage deine Zielgruppe mit den 4 Fragen")
print("  2. Plotte kumulative Kurven")
print("  3. Finde Schnittpunkte")
print("  4. Preise innerhalb der akzeptablen Spanne, nahe OPP")

Die Retention Mathematik: Warum 5% 95% bedeuten können

Die einfache Erklärung

Bain & Company's berühmte Statistik: Eine 5%ige Erhöhung der Retention kann eine 25-95%ige Erhöhung der Profite bedeuten.

Das scheint unmöglich groß. Aber die Mathematik stimmt, wenn du die Zinseszins Effekte verstehst:

1. Keine Wiederakquisekosten: Gehaltene Kunden kosten €0 um sie erneut zu gewinnen.
2. Umsatz akkumuliert: Jede zusätzliche Periode der Retention fügt mehr Umsatz hinzu.
3. Empfehlungen: Langzeitkunden empfehlen mehr.
4. Preistoleranz: Loyale Kunden akzeptieren Preiserhöhungen.
5. Niedrigere Servicekosten: Erfahrene Kunden brauchen weniger Support.

Die Formel

Der Wert verbesserter Retention kann modelliert werden als:

$\Delta LTV = ARPU \times \left(\frac{1}{1-r_{neu}} - \frac{1}{1-r_{alt}}\right)$

Python Implementierung

import numpy as np

def calculate_retention_value_impact(arpu, margin, old_retention, new_retention, cac):
    """
    Berechne den Profit Impact verbesserter Retention.
    """
    
    old_churn = 1 - old_retention
    new_churn = 1 - new_retention
    
    ltv_old = (arpu * margin) / old_churn if old_churn > 0 else float('inf')
    ltv_new = (arpu * margin) / new_churn if new_churn > 0 else float('inf')
    
    profit_old = ltv_old - cac
    profit_new = ltv_new - cac
    
    profit_improvement_pct = (profit_new / profit_old - 1) * 100 if profit_old > 0 else float('inf')
    
    return {
        'ltv_old': ltv_old,
        'ltv_new': ltv_new,
        'profit_improvement_pct': profit_improvement_pct
    }

# Beispiel
result = calculate_retention_value_impact(
    arpu=100, 
    margin=0.80, 
    old_retention=0.95, 
    new_retention=0.97, 
    cac=400
)

print(f"LTV alt: €{result['ltv_old']:,.0f}")
print(f"LTV neu: €{result['ltv_new']:,.0f}")
print(f"Profit Verbesserung: {result['profit_improvement_pct']:.0f}%")

print("\nWarum Retention so viel Hebelwirkung hat:")
print("  1. KEINE WIEDERAKQUISEKOSTEN: CAC gespart")
print("  2. UMSATZ AKKUMULIERT: Jeder Monat mehr = mehr Beitrag")
print("  3. HEBEL AUF CAC: CAC ist fix, LTV Erhöhungen fließen direkt in Profit")

Fazit: Mathematik ist nicht optional

Jedes Prinzip in dieser Serie (Verknappung, Social Proof, Gewohnheitsbildung, alles) generiert Daten. Diese Daten müssen gemessen, modelliert und gehandelt werden.

LTV:CAC sagt dir, ob Growth nachhaltig ist. Unter 3:1 baust du einen löchrigen Eimer.

Payback Period sagt dir, ob du es dir leisten kannst. Langer Payback bedeutet du brauchst Kapital.

Kohortenanalyse enthüllt, was Durchschnitte verstecken. Nie aggregieren, wenn du segmentieren kannst.

Survival Analysis modelliert Churn richtig. Zeit ist wichtig. Kundenalter ist wichtig.

Bayesian Testing gibt dir Wahrscheinlichkeit. Hör auf zu fragen ob p < 0.05 und frag "wie wahrscheinlich ist es, dass B besser ist?"

Bandits reduzieren Opportunitätskosten. Hör auf Traffic 50/50 zu splitten, wenn du gleichzeitig lernen und verdienen kannst.

MMM funktioniert, wenn Attribution nicht funktioniert. Cookies sterben. Top-down Modellierung ist zurück.

Power Laws bedeuten, dass Durchschnitte lügen. Deine Top 1% Kunden sind nicht deine Durchschnittskunden.

Elastizität bestimmt, ob Preiserhöhungen Geld bringen. Teste, miss, modelliere.

Retention akkumuliert. Kleine Verbesserungen in Retention haben überproportionale Profit Auswirkungen.

Das ist die Mathematik, die dateninformiertes Growth von Raten trennt. Jede Formel in diesem Post ist praxiserprobt. Der Code läuft. Die Zahlen funktionieren.

Ich habe jedes Konzept hier über E-Commerce, SaaS und B2B Produkte angewendet. Die Mathematik ist nicht theoretisch. Es ist das Arbeitswerkzeug, das ich benutze, um Entscheidungen über Marketing Spend und Produktinvestitionen zu treffen. Wenn du von Bauchgefühl zu datengetrieben wechseln willst, fang hier an.

Brauchst du Hilfe, diese Modelle für dein Business zu bauen? Oder dein Team in Growth Mathematik zu schulen? Ich kann dir helfen, die Messsysteme zu implementieren und die Analysen durchzuführen. Lass uns reden.