ROIC, Economic Profit & Value Creation

5.1 Why ROIC Is the Central Metric in Valuation

In Chapter 1, we established a fundamental truth: growth creates value only when the return on invested capital exceeds the cost of that capital. ROIC is the metric that makes this truth operational. It answers the question every investor should ask: for every rupee the company invests, how much profit does it generate?

Consider three companies with identical 15% revenue growth:

Company A is a compounding machine. Every rupee reinvested generates 35 paise of after-tax profit — far above the 10% cost. Company C, despite growing at the same rate, is burning value. Its 6% ROIC means each rupee invested earns less than what that capital costs. The 15% growth only accelerates the destruction.

5.2 Computing NOPAT: The Numerator

NOPAT (Net Operating Profit After Tax) is the profit generated by the company's core operations, after tax, but before financing costs. It represents the earnings available to all capital providers — both debt and equity holders. It is the numerator in the ROIC equation.

The simplicity of this formula is deceptive. The adjustment work lies in ensuring EBIT truly reflects operating earnings. Here is the step-by-step approach:

5.2.1 NOPAT in Python

def compute_nopat(income_stmt, tax_rate=0.25, non_operating_income_fields=None):
    """
    Compute NOPAT from an income statement DataFrame.

    Parameters
    ----------
    income_stmt : pd.DataFrame (yfinance .financials format)
    tax_rate : float — effective or statutory tax rate (default 0.25)
    non_operating_income_fields : list of str — income statement line items
        that are non-operating and should be excluded from operating EBIT.

    Returns
    -------
    pd.Series of NOPAT by fiscal year.
    """
    def safe_get(df, candidates):
        for c in ([candidates] if isinstance(candidates, str) else candidates):
            if c in df.index:
                return df.loc[c]
        return None

    ebit = safe_get(income_stmt, ['Operating Income', 'EBIT'])

    if ebit is None:
        # Try to construct EBIT from components
        rev = safe_get(income_stmt, ['Total Revenue', 'Revenue'])
        total_exp = safe_get(income_stmt, ['Total Expenses'])
        if rev is not None and total_exp is not None:
            ebit = rev - total_exp
        else:
            raise ValueError("Cannot find or construct EBIT from income statement.")

    # Strip non-operating income if fields are provided
    if non_operating_income_fields:
        for field in non_operating_income_fields:
            non_op = safe_get(income_stmt, field)
            if non_op is not None:
                ebit = ebit - non_op

    nopat = ebit * (1 - tax_rate)
    return nopat

# Usage
import yfinance as yf
ticker = yf.Ticker("ASIANPAINT.NS")
nopat = compute_nopat(ticker.financials)
print("NOPAT by Fiscal Year (Rs. Cr):")
print((nopat / 1e7).round(2))  # Convert to crores

5.3 Computing Invested Capital: The Denominator

Invested Capital represents the total capital that has been deployed in the company's operations — the capital provided by both debt and equity holders, net of non-operating assets. It is the denominator of ROIC.

5.3.1 The Operating Approach

This builds invested capital from the asset side. Operating current assets include receivables, inventory, and the minimum cash needed for operations — but exclude excess cash. Operating current liabilities include payables and accruals — but exclude interest-bearing short-term debt.

5.3.2 The Financing Approach (Easier from yfinance)

This builds invested capital from the financing side — equity plus debt, minus assets that are not employed in the business. We subtract cash because it is not an operating asset (it generates interest income, not operating profit). We subtract non-operating investments (minority stakes in other companies) for the same reason.

5.3.3 Critical Adjustments

5.3.4 Invested Capital in Python

def compute_invested_capital(balance_sheet, excess_cash_pct=0.0):
    """
    Compute invested capital from balance sheet data.

    By default, treats ALL cash as non-operating (conservative).
    Set excess_cash_pct to ~0.02 (2% of revenue) to treat some cash
    as operating when you have revenue data.
    """
    def safe_get(df, candidates):
        for c in ([candidates] if isinstance(candidates, str) else candidates):
            if c in df.index:
                return df.loc[c]
        return None

    equity = safe_get(balance_sheet, [
        'Total Equity Gross Minority Interest',
        'Stockholders Equity', 'Total Equity'])
    total_debt = safe_get(balance_sheet, [
        'Total Debt', 'Long Term Debt'])
    cash = safe_get(balance_sheet, [
        'Cash And Cash Equivalents',
        'Cash Cash Equivalents And Short Term Investments'])
    lt_investments = safe_get(balance_sheet, [
        'Long Term Investments', 'Investments And Advances'])

    if equity is None:
        # Build from: Total Assets − Total Liabilities
        assets = safe_get(balance_sheet, ['Total Assets'])
        liabilities = safe_get(balance_sheet, ['Total Liabilities Net Minority Interest'])
        if assets is not None and liabilities is not None:
            equity = assets - liabilities
        else:
            raise ValueError("Cannot determine equity from balance sheet.")

    # If there's no separate debt line, use the difference approach
    if total_debt is None:
        total_debt = 0  # In some yfinance outputs, debt is embedded in liabilities

    invested_capital = equity + total_debt

    if cash is not None:
        invested_capital = invested_capital - cash

    if lt_investments is not None:
        # Only subtract if these are truly non-operating
        invested_capital = invested_capital - lt_investments

    return invested_capital


# Usage
ic = compute_invested_capital(ticker.balance_sheet)
print("Invested Capital by Fiscal Year (Rs. Cr):")
print((ic / 1e7).round(2))

5.4 Putting It Together: Computing ROIC

With NOPAT and Invested Capital computed, ROIC follows directly. But the analysis does not stop at a single number — we must examine ROIC trends, compare against WACC, and decompose the drivers.

5.4.1 The Core ROIC Function

def compute_roic(income_stmt, balance_sheet, tax_rate=0.25):
    """
    Compute NOPAT, Invested Capital, and ROIC.

    Returns a DataFrame with all three components by fiscal year.
    """
    nopat = compute_nopat(income_stmt, tax_rate)
    ic = compute_invested_capital(balance_sheet)

    # Align indices (they should match by fiscal year, but verify)
    common_years = nopat.index.intersection(ic.index)
    nopat = nopat[common_years]
    ic = ic[common_years]

    roic = (nopat / ic) * 100

    result = pd.DataFrame({
        'NOPAT (Cr)': nopat / 1e7,
        'Invested Capital (Cr)': ic / 1e7,
        'ROIC (%)': roic.round(2)
    })

    return result


def compare_roic_across_companies(tickers, labels=None, tax_rate=0.25):
    """
    Compute and compare ROIC for multiple companies.

    Returns a DataFrame with each company's latest ROIC and components.
    """
    if labels is None:
        labels = [t.replace('.NS', '').replace('.BO', '') for t in tickers]

    results = {}
    for tkr, lbl in zip(tickers, labels):
        try:
            ticker = yf.Ticker(tkr)
            roic_df = compute_roic(ticker.financials, ticker.balance_sheet, tax_rate)
            latest = roic_df.iloc[:, 0]  # Most recent fiscal year
            results[lbl] = latest
            print(f"✓ {lbl}: ROIC = {latest['ROIC (%)']:.1f}%")
        except Exception as e:
            print(f"✗ {lbl}: {e}")
        time.sleep(1.5)

    comparison = pd.DataFrame(results).T
    return comparison


# --- Compare Indian consumer leaders ---
consumer_tickers = ['ASIANPAINT.NS', 'TITAN.NS', 'NESTLEIND.NS',
                    'BRITANNIA.NS', 'HINDUNILVR.NS']
consumer_labels = ['Asian Paints', 'Titan', 'Nestle India', 'Britannia', 'HUL']

roic_comparison = compare_roic_across_companies(consumer_tickers, consumer_labels)
print("\n=== ROIC Comparison — Indian Consumer Sector ===")
print(roic_comparison)

5.4.2 Interpreting ROIC Levels

5.5 Decomposing ROIC: The Value Driver Formula

A single ROIC number is useful for comparison. But to understand why one company earns 35% while its competitor earns 12%, we must decompose ROIC into its drivers. McKinsey's value driver formula expresses ROIC as the product of operating margin and capital turnover:

This decomposition reveals that there are exactly two ways to earn a high ROIC:

The very best companies — Titan, TCS, Asian Paints — score well on both dimensions. They earn high margins AND turn over capital efficiently. This is the hallmark of a genuinely exceptional business.

5.5.1 Python: ROIC Decomposition

def decompose_roic(income_stmt, balance_sheet, tax_rate=0.25):
    """
    Decompose ROIC into Operating Margin and Capital Turnover.
    """
    def safe_get(df, candidates):
        for c in ([candidates] if isinstance(candidates, str) else candidates):
            if c in df.index:
                return df.loc[c]
        return None

    revenue = safe_get(income_stmt, ['Total Revenue', 'Revenue'])
    nopat = compute_nopat(income_stmt, tax_rate)
    ic = compute_invested_capital(balance_sheet)

    common = nopat.index.intersection(ic.index).intersection(revenue.index)
    nopat = nopat[common]
    ic = ic[common]
    revenue = revenue[common]

    op_margin = (nopat / revenue) * 100
    capital_turnover = revenue / ic
    roic = (nopat / ic) * 100

    decomposition = pd.DataFrame({
        'NOPAT Margin (%)': op_margin.round(2),
        'Capital Turnover (x)': capital_turnover.round(2),
        'ROIC (%)': roic.round(2)
    })

    return decomposition


def plot_roic_decomposition(tickers, labels):
    """
    Scatter plot: Operating Margin vs Capital Turnover,
    with ROIC as isoquants. Each company is a point.
    """
    import matplotlib.pyplot as plt
    import numpy as np

    fig, ax = plt.subplots(figsize=(12, 8))

    for tkr, lbl in zip(tickers, labels):
        try:
            ticker = yf.Ticker(tkr)
            dec = decompose_roic(ticker.financials, ticker.balance_sheet)
            latest = dec.iloc[:, 0]  # Most recent year
            ax.scatter(latest['Capital Turnover (x)'],
                      latest['NOPAT Margin (%)'],
                      s=300, edgecolors='white', linewidth=2, zorder=5)
            ax.annotate(f"{lbl}\nROIC: {latest['ROIC (%)']:.0f}%",
                       (latest['Capital Turnover (x)'],
                        latest['NOPAT Margin (%)']),
                       textcoords="offset points", xytext=(10, 5), fontsize=9)
        except Exception as e:
            print(f"✗ {lbl}: {e}")
        time.sleep(1.5)

    # Add ROIC isoquants
    x_range = np.linspace(0.1, ax.get_xlim()[1] * 1.2, 100)
    for roic_level in [10, 20, 30, 50, 75]:
        y = roic_level / x_range
        ax.plot(x_range, y, '--', color='gray', alpha=0.3, linewidth=0.8)
        ax.annotate(f'{roic_level}% ROIC',
                   (x_range[-1], y[-1]),
                   fontsize=7, color='gray', alpha=0.7,
                   textcoords="offset points", xytext=(5, 0))

    ax.set_xlabel('Capital Turnover (Revenue / Invested Capital)')
    ax.set_ylabel('NOPAT Margin (%)')
    ax.set_title('ROIC Decomposition: How Do Companies Earn Their Returns?',
                 fontsize=13, fontweight='bold')
    ax.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()


# Usage
consumer_tickers = ['ASIANPAINT.NS', 'TITAN.NS', 'NESTLEIND.NS',
                    'BRITANNIA.NS', 'HINDUNILVR.NS']
consumer_labels = ['Asian Paints', 'Titan', 'Nestle India', 'Britannia', 'HUL']
plot_roic_decomposition(consumer_tickers, consumer_labels)

5.6 Economic Profit: The True Measure of Value Creation

Economic Profit (also called Economic Value Added or EVA) measures the absolute amount of value created in a given period — not just the rate of return. While ROIC tells you the efficiency of capital use, Economic Profit tells you the magnitude of value creation.

Economic Profit has a powerful property: it is directly linked to the excess returns in a DCF valuation. The present value of all future Economic Profits, plus the current invested capital, equals the enterprise value from a DCF model. This is the economic profit valuation model — an alternative to the traditional DCF that separates the value of existing capital from the value of future value creation.

5.6.1 Why Net Income Fails to Measure Value Creation

Net income is the most commonly cited profit metric. But it fails as a value creation measure for three reasons:

5.6.2 Computing Economic Profit in Python

def compute_economic_profit(income_stmt, balance_sheet,
                             wacc=0.10, tax_rate=0.25):
    """
    Compute Economic Profit (EVA) = NOPAT − (WACC × Invested Capital).

    If you haven't yet estimated WACC (Chapters 10–11), use 10% as a
    reasonable estimate for Indian companies.
    """
    nopat = compute_nopat(income_stmt, tax_rate)
    ic = compute_invested_capital(balance_sheet)

    common = nopat.index.intersection(ic.index)
    nopat = nopat[common]
    ic = ic[common]

    capital_charge = wacc * ic
    economic_profit = nopat - capital_charge
    roic = (nopat / ic) * 100
    spread = roic - (wacc * 100)

    result = pd.DataFrame({
        'NOPAT (Cr)': (nopat / 1e7).round(2),
        'Invested Capital (Cr)': (ic / 1e7).round(2),
        'ROIC (%)': roic.round(2),
        'WACC (%)': wacc * 100,
        'Spread (%)': spread.round(2),
        'Capital Charge (Cr)': (capital_charge / 1e7).round(2),
        'Economic Profit (Cr)': (economic_profit / 1e7).round(2)
    })

    result['Value Creator?'] = result['Economic Profit (Cr)'] > 0
    return result


# Usage
ticker = yf.Ticker("ASIANPAINT.NS")
ep = compute_economic_profit(ticker.financials, ticker.balance_sheet, wacc=0.10)
print(ep)

5.7 ROIC Trends: What to Look For

A single year's ROIC is informative. The trend over 5–10 years is invaluable. It reveals the trajectory of a company's competitive position.

5.7.1 The Four ROIC Trajectories

5.7.2 Visualizing ROIC Trajectories

def plot_roic_trajectory(ticker_symbol, company_name, wacc=0.10):
    """Plot ROIC trend over time with WACC benchmark."""
    ticker = yf.Ticker(ticker_symbol)
    roic_df = compute_roic(ticker.financials, ticker.balance_sheet)

    fig, axes = plt.subplots(1, 2, figsize=(16, 6))

    # Chart 1: ROIC trend
    ax = axes[0]
    years = [str(d).split('-')[0] for d in roic_df.columns]
    roic_vals = roic_df.loc['ROIC (%)']

    # Color bars: green if > WACC, red if not
    colors = ['#00c9a7' if v > wacc*100 else '#e0556a' for v in roic_vals]
    ax.bar(years, roic_vals, color=colors, edgecolor='white', linewidth=0.5)
    ax.axhline(y=wacc*100, color='orange', linestyle='--', linewidth=2,
               label=f'WACC = {wacc*100:.0f}%')
    ax.set_title(f'{company_name}: ROIC Trend')
    ax.set_ylabel('ROIC (%)')
    ax.legend()
    ax.tick_params(axis='x', rotation=45)

    # Chart 2: NOPAT and Invested Capital growth
    ax = axes[1]
    nopat_growth = roic_df.loc['NOPAT (Cr)'].pct_change(periods=-1) * 100
    ic_growth = roic_df.loc['Invested Capital (Cr)'].pct_change(periods=-1) * 100
    x = range(len(years) - 1)
    w = 0.35
    ax.bar([i - w/2 for i in x], nopat_growth.dropna(), w,
           label='NOPAT Growth %', color='#6c8cff')
    ax.bar([i + w/2 for i in x], ic_growth.dropna(), w,
           label='IC Growth %', color='#f0a040')
    ax.set_xticks(x)
    ax.set_xticklabels(years[1:], rotation=45)
    ax.set_title('NOPAT Growth vs Invested Capital Growth')
    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5)
    ax.legend()
    ax.set_ylabel('Growth Rate (%)')

    # Annotation: if NOPAT grows faster than IC, ROIC is expanding
    plt.suptitle(f'{company_name} — ROIC Analysis',
                 fontsize=14, fontweight='bold', y=1.02)
    plt.tight_layout()
    plt.show()