Financial Ratio Analysis for Valuation

4.1 Why Ratio Analysis Precedes Valuation

A ratio is simply one financial number divided by another. But that simplicity is deceptive. Ratios are the diagnostic toolkit of the valuation practitioner — they reveal a company's financial architecture, its competitive strengths, its vulnerabilities, and the sustainability of its earnings. Before you forecast a single number, you must understand the company through its ratios.

Ratio analysis serves three purposes in the valuation workflow:

We organize ratios into four families, each answering a different question about the business:

4.2 Liquidity Ratios: Can the Company Survive Tomorrow?

Liquidity ratios measure a company's ability to meet its short-term obligations as they fall due. A company can be highly profitable on paper and still go bankrupt if it runs out of cash. Liquidity is about survival.

4.2.1 Current Ratio

The current ratio is the broadest liquidity measure. A ratio of 2.0 means the company has Rs. 2 of current assets for every Rs. 1 of current liabilities. The traditional rule of thumb is 2.0, but this varies enormously by industry:

• Manufacturing (Asian Paints, Tata Motors): 1.5–2.5 is typical — inventory and receivables are substantial.
• IT Services (TCS, Infosys): 3.0–5.0 is common — high cash balances, minimal inventory.
• Retail (Titan, Avenue Supermarts): 0.8–1.5 is normal — retailers collect cash from customers before paying suppliers, so they operate with negative working capital.

4.2.2 Quick Ratio (Acid Test)

The quick ratio strips out inventory — the least liquid current asset. It answers: if all sales stopped tomorrow, could the company pay its immediate bills? A quick ratio below 1.0 is a warning sign except in industries where inventory turns rapidly (FMCG, retail). For a steel company, however, a quick ratio of 0.4 signals potential distress — steel inventory cannot be liquidated quickly at book value.

4.2.3 Cash Ratio

The most conservative liquidity measure. It asks: can the company pay all its short-term obligations with cash on hand alone? Most healthy companies have a cash ratio well below 1.0 — they do not keep idle cash equal to all their current liabilities. A very high cash ratio (above 1.5) may indicate poor capital allocation — money sitting in low-yield bank accounts rather than being invested in the business or returned to shareholders.

4.2.4 Python Implementation

def compute_liquidity_ratios(balance_sheet):
    """
    Compute current, quick, and cash ratios from balance sheet data.

    Parameters
    ----------
    balance_sheet : pd.DataFrame
        yfinance balance_sheet (columns = fiscal years)
    """
    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

    current_assets = safe_get(balance_sheet, [
        'Current Assets', 'Total Current Assets'])
    current_liabilities = safe_get(balance_sheet, [
        'Current Liabilities', 'Total Current Liabilities'])
    inventory = safe_get(balance_sheet, ['Inventory', 'Inventories'])
    cash = safe_get(balance_sheet, [
        'Cash And Cash Equivalents',
        'Cash Cash Equivalents And Short Term Investments'])

    ratios = {}

    if current_assets is not None and current_liabilities is not None:
        ratios['Current Ratio'] = (current_assets / current_liabilities).round(2)

    if current_assets is not None and inventory is not None and current_liabilities is not None:
        ratios['Quick Ratio'] = ((current_assets - inventory) / current_liabilities).round(2)

    if cash is not None and current_liabilities is not None:
        ratios['Cash Ratio'] = (cash / current_liabilities).round(2)

    return pd.DataFrame(ratios)

# Usage
import yfinance as yf
ticker = yf.Ticker("ASIANPAINT.NS")
liquidity = compute_liquidity_ratios(ticker.balance_sheet)
print(liquidity)

4.3 Solvency / Leverage Ratios: Can the Company Survive the Long Term?

Solvency ratios measure a company's ability to meet its long-term debt obligations. While liquidity is about the next 12 months, solvency is about the next decade. High leverage magnifies returns in good times — and magnifies losses in bad times.

4.3.1 Debt-to-Equity Ratio

This is the most widely used leverage ratio. A D/E of 1.0 means the company has equal amounts of debt and equity financing. Indian companies tend to have higher D/E ratios than their US counterparts due to historically higher interest rates making equity financing expensive, and promoter preference for retaining control through debt rather than equity dilution.

Indian sector benchmarks:

4.3.2 Interest Coverage Ratio (ICR)

ICR measures how many times the company can pay its interest obligations from its operating profit. It is arguably more important than D/E because it directly answers the question: can the company service its debt?

• ICR > 5: Comfortable — the company generates ample earnings to cover interest.
• ICR 2–5: Manageable but warrants monitoring — a downturn could strain coverage.
• ICR 1–2: Stressed — a modest earnings decline could make interest payments difficult.
• ICR < 1: Crisis — the company is not generating enough operating profit to cover interest. It is borrowing to pay interest or dipping into reserves.

4.3.3 Debt-to-EBITDA

This ratio measures how many years of EBITDA it would take to pay off all the debt, assuming EBITDA could be entirely devoted to debt repayment. A ratio above 4–5x is generally considered aggressive. Private equity firms routinely model this ratio as a key covenant metric.

4.3.4 Python Implementation

def compute_solvency_ratios(balance_sheet, income_stmt):
    """Compute debt-to-equity, interest coverage, and debt-to-EBITDA."""
    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

    total_debt = safe_get(balance_sheet, ['Total Debt', 'Long Term Debt'])
    equity = safe_get(balance_sheet, [
        'Total Equity Gross Minority Interest',
        'Stockholders Equity', 'Total Equity'])
    ebit = safe_get(income_stmt, ['Operating Income', 'EBIT'])
    interest_expense = safe_get(income_stmt, ['Interest Expense',
                                               'Interest Expense Non Operating'])
    ebitda = safe_get(income_stmt, ['EBITDA'])

    # If EBITDA not directly available, estimate
    if ebitda is None and ebit is not None:
        depreciation = safe_get(income_stmt, [
            'Depreciation And Amortization',
            'Depreciation Amortization Depletion'])
        if depreciation is not None:
            ebitda = ebit + depreciation

    ratios = {}

    if total_debt is not None and equity is not None:
        ratios['Debt-to-Equity'] = (total_debt / equity).round(2)

    if ebit is not None and interest_expense is not None:
        # Avoid division by zero
        icr = ebit / interest_expense.replace(0, np.nan)
        ratios['Interest Coverage'] = icr.round(2)

    if total_debt is not None and ebitda is not None:
        ratios['Debt-to-EBITDA'] = (total_debt / ebitda).round(2)

    return pd.DataFrame(ratios)

4.4 Profitability Ratios: How Much Money Does the Business Actually Make?

Profitability ratios measure a company's ability to generate profit relative to its revenue, assets, and equity. They are the most directly valuation-relevant family of ratios because profit generation is the engine that drives free cash flow.

4.4.1 Margin Ratios

We introduced margins in Chapters 2 and 3. Here we formalize them into a unified framework and add the interpretation layer.

4.4.2 Return Ratios

While margins measure profit per rupee of revenue, return ratios measure profit per rupee of investment. For valuation, return ratios are more important than margins because they capture capital efficiency.

Return on Assets (ROA):

ROA measures how efficiently the company uses its total asset base to generate profit. ROA varies dramatically by business model: an IT services company with minimal physical assets might show 15–20% ROA, while a steel manufacturer with massive PPE might show 3–5%. Comparing ROA across sectors is meaningless; comparing ROA within a sector identifies the most asset-efficient operators.

Return on Equity (ROE):

ROE measures the return earned on shareholders' capital. It is the most watched profitability metric by equity investors. However, ROE can be inflated by leverage — a company can boost ROE simply by taking on more debt. This is the DuPont effect.

4.4.3 The DuPont Decomposition

The DuPont formula decomposes ROE into three drivers, revealing why ROE is high or low:

This decomposition is invaluable for valuation. A company with a 25% ROE achieved through a 20% net margin and low leverage (Titan) is fundamentally higher quality than a company with a 25% ROE achieved through a 5% margin and 5x leverage (an infrastructure developer). The former's earnings are sustainable; the latter's are fragile.

4.4.4 Python Implementation

def compute_profitability_ratios(income_stmt, balance_sheet):
    """Compute margins, ROA, ROE, and DuPont decomposition."""
    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

    rev = safe_get(income_stmt, ['Total Revenue', 'Revenue'])
    gp  = safe_get(income_stmt, ['Gross Profit'])
    ebit = safe_get(income_stmt, ['Operating Income', 'EBIT'])
    ni  = safe_get(income_stmt, ['Net Income', 'Net Income Common Stockholders'])
    ebitda = safe_get(income_stmt, ['EBITDA'])
    assets = safe_get(balance_sheet, ['Total Assets'])
    equity = safe_get(balance_sheet, [
        'Total Equity Gross Minority Interest',
        'Stockholders Equity', 'Total Equity'])

    ratios = {}

    if gp is not None and rev is not None:
        ratios['Gross Margin (%)'] = (gp / rev * 100).round(2)
    if ebit is not None and rev is not None:
        ratios['Operating Margin (%)'] = (ebit / rev * 100).round(2)
    if ni is not None and rev is not None:
        ratios['Net Margin (%)'] = (ni / rev * 100).round(2)
    if ebitda is not None and rev is not None:
        ratios['EBITDA Margin (%)'] = (ebitda / rev * 100).round(2)
    if ni is not None and assets is not None:
        ratios['ROA (%)'] = (ni / assets * 100).round(2)
    if ni is not None and equity is not None:
        ratios['ROE (%)'] = (ni / equity * 100).round(2)

    # DuPont decomposition
    if ni is not None and rev is not None and assets is not None and equity is not None:
        net_margin = ni / rev
        asset_turnover = rev / assets
        equity_multiplier = assets / equity
        ratios['DuPont — Net Margin'] = (net_margin * 100).round(2)
        ratios['DuPont — Asset Turnover'] = asset_turnover.round(2)
        ratios['DuPont — Equity Multiplier'] = equity_multiplier.round(2)

    return pd.DataFrame(ratios)

4.5 Efficiency / Activity Ratios: How Well Is the Company Managed?

Efficiency ratios measure how effectively a company uses its assets and manages its working capital. Two companies with identical margins can have vastly different free cash flows if one ties up twice as much capital in receivables and inventory.

4.5.1 Asset Turnover

This is the broadest efficiency measure. It answers: how many rupees of revenue does the company generate for each rupee of assets? An asset turnover of 2.0 means Rs. 2 of revenue per Rs. 1 of assets. Asset-light businesses (IT services, consulting) have high turnover (1.5–3.0); asset-heavy businesses (steel, power) have low turnover (0.3–0.8).

4.5.2 Working Capital Ratios

These three ratios form the cash conversion cycle — the time between paying suppliers and collecting from customers:

4.5.3 The Cash Conversion Cycle

The CCC measures how many days of working capital financing are needed to run the business. A negative CCC means the company collects from customers before it pays suppliers — it is effectively financed by its suppliers. This is the holy grail of working capital management. DMart (Avenue Supermarts) consistently runs a negative CCC because it collects cash from customers instantly but pays suppliers on 30–45 day terms.

4.5.4 Python Implementation

def compute_efficiency_ratios(income_stmt, balance_sheet):
    """Compute asset turnover and working capital efficiency ratios."""
    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

    rev = safe_get(income_stmt, ['Total Revenue', 'Revenue'])
    cogs = safe_get(income_stmt, ['Cost Of Goods Sold', 'Cost of Revenue'])
    assets = safe_get(balance_sheet, ['Total Assets'])
    ar = safe_get(balance_sheet, ['Accounts Receivable',
                                   'Net Receivables', 'Receivables'])
    inv = safe_get(balance_sheet, ['Inventory', 'Inventories'])
    ap = safe_get(balance_sheet, ['Accounts Payable', 'Payables'])

    ratios = {}

    if rev is not None and assets is not None:
        ratios['Asset Turnover'] = (rev / assets).round(2)

    if rev is not None and ar is not None:
        ratios['Receivable Turnover'] = (rev / ar).round(2)
        ratios['Days Sales Outstanding'] = (365 / ratios['Receivable Turnover']).round(0)

    if cogs is not None and inv is not None:
        ratios['Inventory Turnover'] = (cogs / inv).round(2)
        ratios['Days Inventory Outstanding'] = (365 / ratios['Inventory Turnover']).round(0)

    if cogs is not None and ap is not None:
        ratios['Payable Turnover'] = (cogs / ap).round(2)
        ratios['Days Payable Outstanding'] = (365 / ratios['Payable Turnover']).round(0)

    # Cash Conversion Cycle
    if all(k in ratios for k in ['Days Sales Outstanding',
                                   'Days Inventory Outstanding',
                                   'Days Payable Outstanding']):
        ratios['Cash Conversion Cycle'] = (
            ratios['Days Sales Outstanding'] +
            ratios['Days Inventory Outstanding'] -
            ratios['Days Payable Outstanding'])

    return pd.DataFrame(ratios)

4.6 The Complete Ratio Analysis Pipeline

Now we combine all four ratio families into a single, comprehensive analysis function that produces a complete financial diagnostic for any company:

def full_ratio_analysis(ticker_symbol):
    """
    Perform a complete financial ratio analysis for any company.

    Returns a dict with four DataFrames (liquidity, solvency,
    profitability, efficiency) plus the latest-year summary.
    """
    ticker = yf.Ticker(ticker_symbol)
    info = ticker.info
    is_df = ticker.financials
    bs_df = ticker.balance_sheet
    cf_df = ticker.cashflow

    results = {
        'ticker': ticker_symbol,
        'company': info.get('longName', ticker_symbol),
        'sector': info.get('sector', 'N/A'),
        'market_cap': info.get('marketCap', None),
        'liquidity': compute_liquidity_ratios(bs_df),
        'solvency': compute_solvency_ratios(bs_df, is_df),
        'profitability': compute_profitability_ratios(is_df, bs_df),
        'efficiency': compute_efficiency_ratios(is_df, bs_df),
    }

    # Build a single-row summary (latest year)
    summary = {}
    for family in ['liquidity', 'solvency', 'profitability', 'efficiency']:
        df = results[family]
        if not df.empty:
            latest_col = df.columns[0]
            for idx in df.index:
                summary[idx] = df.loc[idx, latest_col]

    results['summary'] = pd.Series(summary).round(2)

    return results


def compare_ratios(tickers, labels=None):
    """Compare ratio summaries across multiple companies."""
    if labels is None:
        labels = [t.replace('.NS', '').replace('.BO', '') for t in tickers]

    summaries = {}
    for ticker, label in zip(tickers, labels):
        try:
            r = full_ratio_analysis(ticker)
            summaries[label] = r['summary']
            print(f"✓ {label}")
        except Exception as e:
            print(f"✗ {label}: {e}")
        time.sleep(1.5)

    return pd.DataFrame(summaries)


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

comparison = compare_ratios(consumer_tickers, consumer_labels)

# Display only key metrics
key_metrics = [
    'Current Ratio', 'Debt-to-Equity', 'Interest Coverage',
    'Gross Margin (%)', 'Operating Margin (%)', 'Net Margin (%)',
    'ROE (%)', 'Asset Turnover', 'Cash Conversion Cycle'
]
print("\n=== Indian Consumer Sector — Key Ratio Comparison ===")
print(comparison.loc[comparison.index.intersection(key_metrics)])

def compute_interest_coverage(income_stmt):
    ebit = income_stmt.loc['Operating Income']
    interest = income_stmt.loc['Interest Expense']
    return ebit / interest   # crashes for debt-free companies!

4.7 Interpreting Ratios: The Art Behind the Numbers

Computing ratios is mechanical. Interpreting them requires judgment. Here is a framework for extracting insight from the numbers:

4.7.1 The Three-Lens Test

For every ratio, apply three lenses before drawing a conclusion:

4.7.2 Ratio Interaction Patterns

Ratios do not exist in isolation. Certain combinations of ratios tell a coherent story: