Startup, Private Company & M&A Valuation

PART A — STARTUP & PRIVATE COMPANY VALUATION

17.1 Why Startups Are Different

Valuing a startup or private company presents challenges that the DCF and multiples frameworks we built in Chapters 1–16 do not fully address:

These challenges have spawned specialized valuation methods. The three most widely used in venture capital are the Venture Capital method, the Scorecard method, and the First Chicago method.

17.2 The Venture Capital Method

The VC method is the most widely used startup valuation approach. It works backward from the expected exit: estimate the company's value at exit (typically 5–7 years out), then discount that terminal value back to today at the VC's target rate of return (typically 30–60%).

The VC's target IRR is high (30–60%) because startup investments are illiquid, concentrated, and have a high probability of total loss. This is fundamentally different from the WACC we computed in Chapter 11 — it is a required return, not a cost of capital.

import numpy as np
import pandas as pd

def venture_capital_method(terminal_revenue, terminal_margin,
                            terminal_pe_multiple, target_irr,
                            years_to_exit, investment_amount,
                            dilution_pct=0.30):
    """
    Venture Capital valuation method.

    Parameters
    ----------
    terminal_revenue : float — projected revenue at exit year (Rs. Cr)
    terminal_margin : float — net margin at exit
    terminal_pe_multiple : float — expected P/E at exit (industry comparable)
    target_irr : float — VC's target annual return (e.g., 0.40 for 40%)
    years_to_exit : int — expected years to IPO/acquisition
    investment_amount : float — amount being invested now (Rs. Cr)
    dilution_pct : float — expected dilution from future rounds + ESOPs

    Returns
    -------
    dict with pre-money, post-money, ownership, and implied metrics.
    """
    # Terminal value at exit
    terminal_net_income = terminal_revenue * terminal_margin
    terminal_equity_value = terminal_net_income * terminal_pe_multiple

    # Post-money valuation today = PV of terminal value
    post_money = terminal_equity_value / (1 + target_irr) ** years_to_exit

    # Account for future dilution
    retained_pct = 1 - dilution_pct
    post_money_dilution_adj = post_money * retained_pct

    # Pre-money
    pre_money = post_money_dilution_adj - investment_amount

    # Ownership required
    ownership_required = investment_amount / post_money_dilution_adj

    print(f"VENTURE CAPITAL METHOD")
    print(f"{'='*45}")
    print(f"  Terminal Year:               {years_to_exit} years from now")
    print(f"  Terminal Revenue:            Rs. {terminal_revenue:,.0f} Cr")
    print(f"  Terminal Net Margin:         {terminal_margin*100:.0f}%")
    print(f"  Terminal Net Income:         Rs. {terminal_net_income:,.0f} Cr")
    print(f"  Terminal P/E Multiple:       {terminal_pe_multiple:.1f}x")
    print(f"  Terminal Equity Value:       Rs. {terminal_equity_value:,.0f} Cr")
    print(f"  ───────────────────────────────────────")
    print(f"  Target IRR:                  {target_irr*100:.0f}%")
    print(f"  Discount Factor:             {1/(1+target_irr)**years_to_exit:.4f}")
    print(f"  Post-Money (undiluted):      Rs. {post_money:,.0f} Cr")
    print(f"  Dilution (future rounds):    {dilution_pct*100:.0f}%")
    print(f"  Post-Money (dilution-adj):   Rs. {post_money_dilution_adj:,.0f} Cr")
    print(f"  (−) Investment:              Rs. {investment_amount:,.0f} Cr")
    print(f"  Pre-Money Valuation:         Rs. {pre_money:,.0f} Cr")
    print(f"  ───────────────────────────────────────")
    print(f"  Ownership Required:          {ownership_required*100:.1f}%")

    # Implied revenue multiple today
    current_revenue = terminal_revenue / (1 + 0.80) ** years_to_exit  # Assume high growth
    implied_ev_rev = post_money_dilution_adj / current_revenue if current_revenue > 0 else None
    if implied_ev_rev:
        print(f"\n  Implied Current EV/Revenue:  {implied_ev_rev:.1f}x")

    return {
        'pre_money': pre_money,
        'post_money': post_money_dilution_adj,
        'ownership_required': ownership_required,
        'terminal_equity_value': terminal_equity_value,
        'implied_money_multiple': terminal_equity_value / investment_amount,
    }


# --- Example: Series A valuation of an Indian SaaS startup ---
vc_result = venture_capital_method(
    terminal_revenue=800,       # Rs. 800 Cr revenue in Year 7
    terminal_margin=0.20,       # 20% net margin
    terminal_pe_multiple=25,    # 25x P/E (SaaS sector multiple)
    target_irr=0.45,            # 45% target IRR (early-stage VC)
    years_to_exit=7,
    investment_amount=50,       # Rs. 50 Cr Series A investment
    dilution_pct=0.35           # 35% dilution from Series B, C, ESOPs
)

17.2.1 VC Method Sensitivity

# Sensitivity: Pre-money at varying IRR and Terminal P/E
print(f"\n=== PRE-MONEY SENSITIVITY (Rs. Cr) ===")
irr_range = [0.30, 0.35, 0.40, 0.45, 0.50, 0.60]
pe_range = [15, 20, 25, 30, 35]
print(f"{'IRR \\ P/E':<10}", end="")
for pe in pe_range:
    print(f"{pe}x".rjust(10), end="")
print()
for irr in irr_range:
    print(f"{irr*100:.0f}%".ljust(10), end="")
    for pe in pe_range:
        tv = 800 * 0.20 * pe  # Terminal equity value
        pm = tv / (1 + irr) ** 7 * 0.65  # post-money (dilution adj)
        pre = pm - 50
        print(f"{pre:,.0f}".rjust(10), end="")
    print()

17.3 The Scorecard Method

The Scorecard method is used for pre-revenue or very early-stage startups where even the VC method is impractical (no revenue to project). It starts with the average pre-money valuation of comparable startups in the same sector and stage, then adjusts it up or down based on qualitative factors.

def scorecard_method(avg_peer_pre_money, factor_scores):
    """
    Scorecard valuation method for pre-revenue startups.

    Parameters
    ----------
    avg_peer_pre_money : float — average pre-money of comparable startups (Rs. Cr)
    factor_scores : dict — {factor_name: (weight, score)}
        weight : float — 0 to 1, sum of all weights = 1.0
        score : float — 0.5 to 1.5
            1.0 = average, >1.0 = above average, <1.0 = below average

    Returns
    -------
    Adjusted pre-money valuation.
    """
    weighted_score = 0
    print(f"SCORECARD METHOD")
    print(f"{'='*50}")
    print(f"  Average Peer Pre-Money: Rs. {avg_peer_pre_money:,.0f} Cr\n")
    print(f"  {'Factor':<25} {'Weight':<8} {'Score':<8} {'Weighted'}")
    print(f"  {'─'*50}")

    for factor, (weight, score) in factor_scores.items():
        w_score = weight * score
        weighted_score += w_score
        print(f"  {factor:<25} {weight*100:>4.0f}%    {score:.1f}      {w_score:.2f}")

    total_weight = sum(w for w, _ in factor_scores.values())
    print(f"  {'─'*50}")
    print(f"  {'Total':<25} {total_weight*100:>4.0f}%             {weighted_score:.2f}")

    adjusted_pre_money = avg_peer_pre_money * weighted_score

    print(f"\n  Weighted Average Score: {weighted_score:.2f}")
    print(f"  Adjustment: {(weighted_score - 1)*100:+.0f}% vs peer average")
    print(f"  Adjusted Pre-Money: Rs. {adjusted_pre_money:,.0f} Cr")

    return adjusted_pre_money


# --- Example: Pre-revenue health-tech startup ---
factor_scores = {
    'Team':                  (0.30, 1.4),   # Strong founding team with prior exits
    'Market / TAM':          (0.25, 1.3),   # Large and growing healthcare market
    'Product / Technology':  (0.15, 1.1),   # MVP stage, some IP filed
    'Competitive Position':  (0.10, 0.9),   # Several funded competitors
    'Go-to-Market / Sales':  (0.10, 0.8),   # Early stage, no partnerships yet
    'Funding / Traction':    (0.10, 1.0),   # Average traction for stage
}

scorecard_pre_money = scorecard_method(
    avg_peer_pre_money=80,   # Rs. 80 Cr — median Series A in Indian health-tech
    factor_scores=factor_scores
)

17.4 The First Chicago Method

The First Chicago method — named after First Chicago Bank's venture group — addresses the fundamental uncertainty of startups by modeling multiple scenarios with explicit probabilities. It is a hybrid of DCF and scenario analysis, custom-built for high-uncertainty investments.

def first_chicago_method(scenarios):
    """
    First Chicago method — probability-weighted scenario valuation.

    Parameters
    ----------
    scenarios : list of dicts, each with:
        - 'name': str — scenario name
        - 'probability': float — 0 to 1
        - 'value': float — enterprise/equity value in that scenario (Rs. Cr)

    Returns
    -------
    Expected value and scenario breakdown.
    """
    total_prob = sum(s['probability'] for s in scenarios)
    if abs(total_prob - 1.0) > 0.01:
        print(f"WARNING: Probabilities sum to {total_prob:.2f} — should be 1.0")

    expected_value = sum(s['value'] * s['probability'] for s in scenarios)

    print(f"FIRST CHICAGO METHOD")
    print(f"{'='*55}")
    print(f"  {'Scenario':<25} {'Prob':<8} {'Value (Cr)':<15} {'Weighted'}")
    print(f"  {'─'*55}")

    for s in scenarios:
        weighted = s['value'] * s['probability']
        print(f"  {s['name']:<25} {s['probability']*100:>4.0f}%    "
              f"Rs. {s['value']:>10,.0f}    Rs. {weighted:>10,.0f}")

    print(f"  {'─'*55}")
    print(f"  EXPECTED VALUE:                          Rs. {expected_value:>10,.0f} Cr")

    # Range statistics
    values = [s['value'] for s in scenarios]
    print(f"\n  Value Range: Rs. {min(values):,.0f} – {max(values):,.0f} Cr")
    print(f"  Spread:      Rs. {max(values) - min(values):,.0f} Cr "
          f"({(max(values)/min(values)-1)*100:.0f}% upside from worst to best)")

    return {
        'expected_value': expected_value,
        'scenario_values': {s['name']: s['value'] for s in scenarios},
        'value_range': (min(values), max(values)),
    }


# --- Example: Indian fintech startup ---
scenarios = [
    {
        'name': 'Home Run (IPO at $2B+)',
        'probability': 0.10,
        'value': 15000,  # Rs. Cr
    },
    {
        'name': 'Success (Solid Exit)',
        'probability': 0.25,
        'value': 6000,
    },
    {
        'name': 'Survival (Modest Exit)',
        'probability': 0.30,
        'value': 1500,
    },
    {
        'name': 'Zombie (Acqui-hire)',
        'probability': 0.20,
        'value': 200,
    },
    {
        'name': 'Failure (Zero Recovery)',
        'probability': 0.15,
        'value': 0,
    },
]

fc_result = first_chicago_method(scenarios)
print(f"\n  Expected MOIC at Rs. 500 Cr investment: "
      f"{fc_result['expected_value']/500:.1f}x")

17.5 DCF for Unlisted Companies

For mature private companies with stable cash flows (manufacturing, services, infrastructure), the standard DCF framework from Chapters 12–14 applies — with three important modifications:

def private_company_dcf(fcff_forecast, terminal_g, industry_beta,
                         target_de, rf=0.0675, erp=0.0725, tax=0.25,
                         credit_spread=0.025, total_beta_adjustment=True,
                         illiquidity_discount=0.25):
    """
    DCF valuation adapted for private/unlisted companies.

    Returns DCF value, total beta, cost of equity, and value after
    illiquidity discount.
    """
    # 1. Bottom-up beta
    unlevered_beta = industry_beta / (1 + (1 - tax) * 0.2)  # assume avg peer D/E=0.2
    relevered_beta = unlevered_beta * (1 + (1 - tax) * target_de)
    adjusted_beta = (2/3) * relevered_beta + (1/3)

    # 2. Total beta (for undiversified owner)
    if total_beta_adjustment:
        correlation_with_market = 0.4  # Typical for mid-size private companies
        total_beta = adjusted_beta / correlation_with_market
        ke_label = 'Ke (Total Beta)'
        ke = rf + total_beta * erp
    else:
        total_beta = adjusted_beta
        ke_label = 'Ke (CAPM)'
        ke = rf + adjusted_beta * erp

    # 3. WACC
    e_w = 1 / (1 + target_de)
    d_w = target_de / (1 + target_de)
    kd_post = (rf + credit_spread) * (1 - tax)
    wacc = e_w * ke + d_w * kd_post

    # 4. DCF
    n = len(fcff_forecast)
    pv_exp = sum(fcff / (1 + wacc) ** (t + 0.5) for t, fcff in enumerate(fcff_forecast, 1))
    tv = fcff_forecast[-1] * (1 + terminal_g) / (wacc - terminal_g)
    pv_tv = tv / (1 + wacc) ** n
    enterprise_value = pv_exp + pv_tv
    equity_value_before_discount = enterprise_value - 0  # net debt assumed 0

    # 5. Illiquidity discount
    illiquidity_amount = equity_value_before_discount * illiquidity_discount
    equity_value_after = equity_value_before_discount - illiquidity_amount

    print(f"PRIVATE COMPANY DCF VALUATION")
    print(f"{'='*50}")
    print(f"  Industry Beta (unlevered):   {unlevered_beta:.2f}")
    print(f"  Relevered Beta (D/E={target_de}): {adjusted_beta:.2f}")
    print(f"  {ke_label}:      {ke*100:.2f}%")
    print(f"  WACC:                        {wacc*100:.2f}%")
    print(f"\n  Enterprise Value:            Rs. {enterprise_value:,.0f} Cr")
    print(f"  Illiquidity Discount ({illiquidity_discount*100:.0f}%):  "
          f"Rs. {illiquidity_amount:,.0f} Cr")
    print(f"  Equity Value (marketable):   Rs. {equity_value_after:,.0f} Cr")

    return {
        'unlevered_beta': unlevered_beta, 'relevered_beta': adjusted_beta,
        'total_beta': total_beta, 'ke': ke, 'wacc': wacc,
        'enterprise_value': enterprise_value,
        'equity_value_marketable': equity_value_after,
    }


# --- Example: Private manufacturing company ---
fcff_private = [45, 55, 65, 75, 85]  # Rs. Cr, growing from small base
private_dcf = private_company_dcf(
    fcff_forecast=fcff_private, terminal_g=0.03,
    industry_beta=0.95, target_de=0.3,
    illiquidity_discount=0.25
)

PART B — M&A VALUATION & SYNERGY ANALYSIS

17.6 M&A Valuation: Beyond Standalone Value

In an M&A transaction, the acquirer pays more than the target's standalone value. The difference is the acquisition premium, which is justified by synergies — the additional value created when two businesses are combined. M&A valuation answers three questions:

1. What is the target worth on a standalone basis? (Use DCF + relative valuation from Ch 12–16)
2. What is the combined entity worth? (Standalone values + PV of synergies)
3. How much of the synergies should the acquirer share with the target's shareholders? (Determines the offer price range)

17.7 Synergy Valuation: Revenue, Cost, and Financial Synergies

Synergies fall into three categories. Each must be quantified separately, and each carries a different level of certainty — and therefore a different discount rate.

def synergy_valuation(target_standalone_value, revenue_synergies,
                       cost_synergies, financial_synergies,
                       restructuring_costs=0, integration_costs=0,
                       wacc=0.10, prob_revenue=0.60, prob_cost=0.85):
    """
    Value M&A synergies with probability adjustment.

    Parameters
    ----------
    target_standalone_value : float — DCF value of target alone
    revenue_synergies : list — annual revenue synergy cash flows (after-tax)
    cost_synergies : list — annual cost synergy cash flows (after-tax)
    financial_synergies : list — annual financial synergy benefits
    restructuring_costs : float — one-time costs (severance, facility closure)
    integration_costs : float — expected integration costs over 3 years
    wacc : float — discount rate (use acquirer's WACC for synergies)
    prob_revenue : float — probability revenue synergies are achieved
    prob_cost : float — probability cost synergies are achieved

    Returns
    -------
    dict with standalone value, synergy value, total combined value,
    and offer price range.
    """
    # Discount synergies
    pv_revenue = sum(rs / (1 + wacc) ** (t + 1) for t, rs in enumerate(revenue_synergies))
    pv_cost = sum(cs / (1 + wacc) ** (t + 1) for t, cs in enumerate(cost_synergies))
    pv_financial = sum(fs / (1 + wacc) ** (t + 1) for t, fs in enumerate(financial_synergies))

    # Probability-adjusted
    pv_revenue_adj = pv_revenue * prob_revenue
    pv_cost_adj = pv_cost * prob_cost
    pv_financial_adj = pv_financial * 1.0  # Financial synergies are near-certain

    total_synergies = pv_revenue_adj + pv_cost_adj + pv_financial_adj

    # Net of costs
    total_synergies_net = total_synergies - restructuring_costs - integration_costs

    # Combined value
    combined_value = target_standalone_value + total_synergies_net

    # Offer price range
    max_offer = target_standalone_value + total_synergies_net  # Acquirer keeps nothing
    min_offer = target_standalone_value  # Acquirer keeps all synergies

    # Fair offer: acquirer and target share synergies (typical: 50/50)
    fair_offer = target_standalone_value + total_synergies_net * 0.50

    print(f"M&A SYNERGY VALUATION")
    print(f"{'='*55}")
    print(f"  Target Standalone Value:    Rs. {target_standalone_value:,.0f} Cr")
    print(f"\n  Synergies (Probability-Adjusted):")
    print(f"    Revenue (P={prob_revenue:.0%}):     Rs. {pv_revenue_adj:,.0f} Cr")
    print(f"    Cost (P={prob_cost:.0%}):        Rs. {pv_cost_adj:,.0f} Cr")
    print(f"    Financial:                Rs. {pv_financial_adj:,.0f} Cr")
    print(f"    Total Gross Synergies:    Rs. {total_synergies:,.0f} Cr")
    print(f"    (−) Restructuring:        Rs. {restructuring_costs:,.0f} Cr")
    print(f"    (−) Integration:          Rs. {integration_costs:,.0f} Cr")
    print(f"    Net Synergies:            Rs. {total_synergies_net:,.0f} Cr")
    print(f"\n  COMBINED VALUE:             Rs. {combined_value:,.0f} Cr")
    print(f"\n  OFFER PRICE RANGE:")
    print(f"    Minimum (0% synergies):   Rs. {min_offer:,.0f} Cr  "
          f"({min_offer/target_standalone_value*100:.0f}% of standalone)")
    print(f"    Fair (50% synergies):     Rs. {fair_offer:,.0f} Cr  "
          f"({fair_offer/target_standalone_value*100:.0f}% of standalone)")
    print(f"    Maximum (100% synergies): Rs. {max_offer:,.0f} Cr  "
          f"({max_offer/target_standalone_value*100:.0f}% of standalone)")
    print(f"\n  Control Premium (at Fair Offer): "
          f"{(fair_offer/target_standalone_value - 1)*100:.1f}%")

    return {
        'standalone_value': target_standalone_value,
        'net_synergies': total_synergies_net,
        'combined_value': combined_value,
        'min_offer': min_offer,
        'fair_offer': fair_offer,
        'max_offer': max_offer,
        'control_premium': (fair_offer / target_standalone_value - 1) * 100,
    }


# --- Example: Acquisition of a mid-size IT services company ---
synergy_result = synergy_valuation(
    target_standalone_value=2500,  # DCF value of target
    revenue_synergies=[30, 60, 80, 90, 90],    # Cross-selling, after-tax
    cost_synergies=[50, 80, 100, 100, 100],     # Headcount optimization, procurement
    financial_synergies=[15, 20, 20, 20, 20],   # Lower borrowing cost, tax benefits
    restructuring_costs=80,     # Severance, office closures
    integration_costs=120,      # System migration, rebranding
    wacc=0.10,
    prob_revenue=0.55,  # Revenue synergies are uncertain
    prob_cost=0.85      # Cost synergies are more achievable
)

17.8 Control Premium and Offer Price Strategy

The control premium is the additional amount an acquirer pays above the target's current market price (or standalone value) to gain control. In Indian M&A, control premiums have historically ranged from 15% to 50%+, driven by the promoter-dominated ownership structure.

17.8.1 Indian Control Premium Data

17.8.2 The Acquirer's Decision Rule

def offer_price_analysis(synergy_result, target_shares_outstanding=10):
    """
    Analyze offer price and value creation at different premium levels.

    Returns the per-share offer price range and acquirer value creation.
    """
    standalone = synergy_result['standalone_value']
    synergies = synergy_result['net_synergies']
    shares = target_shares_outstanding  # crore shares

    standalone_per_share = standalone / shares

    print(f"OFFER PRICE ANALYSIS")
    print(f"{'='*55}")
    print(f"  Target Standalone Value/Share: Rs. {standalone_per_share:,.0f}")

    print(f"\n  {'Premium':<10} {'Offer/Share':<15} {'Total Offer':<15} "
          f"{'Acquirer Value':<18} {'Decision'}")
    print(f"  {'─'*65}")

    for premium_pct in [0, 10, 15, 20, 30, 40, 50]:
        offer_per_share = standalone_per_share * (1 + premium_pct / 100)
        total_offer = offer_per_share * shares
        acquirer_value = synergies - (total_offer - standalone)
        decision = 'ACCEPT ✓' if acquirer_value > 0 else 'REJECT ✗'

        print(f"  {premium_pct:>4}%      Rs. {offer_per_share:>8,.0f}     "
              f"Rs. {total_offer:>8,.0f}    Rs. {acquirer_value:>+8,.0f} Cr     "
              f"{decision}")

    # Maximum acceptable premium
    max_premium = synergies / standalone * 100
    print(f"\n  Maximum Acceptable Premium: {max_premium:.1f}%")
    print(f"  At premiums above {max_premium:.1f}%, the acquirer destroys value.")


# --- Run offer analysis ---
offer_price_analysis(synergy_result, target_shares_outstanding=10)