Create a dividend policy simulator: payout targets, leverage/rating guardrails, cash…
- User
Create a dividend policy simulator: payout targets, leverage/rating guardrails, cash runway scenarios, and CFO/board decision pack.
Assistant
The user wants a "dividend policy simulator." This is a financial modeling tool, likely for a corporate finance context. The request has specific components:
- Payout Targets: Modeling how much of earnings (or cash flow) is returned to shareholders.
- Leverage/Rating Guardrails: Constraints based on debt levels (e.g., Net Debt/EBITDA) and credit ratings. If leverage gets too high, dividends might need to be cut to preserve the rating.
- Cash Runway Scenarios: What happens in a downturn? How long can the company sustain a dividend if earnings drop?
- CFO/Board Decision Pack: The output needs to be a professional summary/dashboard suitable for executive decision-making.
Target Audience: Corporate finance professionals, CFOs, Treasurers, Board Members. Format: Python script (using
streamlitor a Jupyter notebook approach withpandasandplotlyfor visualization) is usually the best way to create a "simulator" that is interactive and visual. A complex Excel model is hard to "output" as a single response, so a Python app structure is more practical to demonstrate the logic and provide a usable tool structure.Key Logic/Algorithm:
- Inputs: Starting metrics (EBITDA, Debt, Cash, Current Rating), Target Payout Ratio (%), Stress Test parameters (Revenue decline %).
- Simulation:
- Project financials over years.
- Calculate FCF (Free Cash Flow).
- Apply Payout Policy: Dividend = Target % * Earnings/FCF.
- Check Guardrails:
- Leverage: Is Net Debt/EBITDA > Threshold?
- Cash: Is Cash Balance < Minimum Buffer?
- Adjustment Mechanism: If a guardrail is breached, the simulator cuts the dividend to repair the balance sheet or maintain cash.
- Outputs: Charts showing Dividend per Share, Payout Ratio, Leverage Ratio over time. A summary table for the "Decision Pack."
Structuring the Response:
- Introduction: Briefly explain the framework (The "Iron Triangle" of Capex, Dividends, and Balance Sheet).
- Python Code: A full, runnable Streamlit application. This is the most high-value deliverable. It allows the user to tweak sliders and see results immediately.
- Libraries:
streamlit,pandas,numpy,plotly. - Class Structure: A
DividendSimulatorclass to keep the math clean. - UI: Sidebar for inputs, main area for charts and tables.
- Libraries:
- Explanation of the "Decision Pack": Detail what specific metrics a Board looks at (e.g., Coverage Ratios, Net Debt leverage).
- Strategic Considerations: Briefly mention the "Signaling Effect" (cutting dividends is bad news) vs. "Agency Costs" (hoarding cash is bad).
Refining the Simulator Logic:
- Year 0: Base state.
- Year 1-5: Projections.
- Logic:
EBITDAevolves based on growth rate (or stress scenario).Capexis fixed or % of sales.FCF= EBITDA - Interest - Tax - Capex - Debt Repayment.Proposed Dividend=Target_Payout*Net_Income(or FCF).Actual Dividend=Proposed Dividend.- Guardrail Check:
- If
New_Net_Debt / New_EBITDA>Max_Leverage, then cut Dividend to maintainMax_Leverage. - If
Ending_Cash<Min_Cash_Runway, then Cut Dividend to preserve cash.
- If
- Rating Impact: Simple mapping (e.g., < 2.0x is AAA/A, 2.0-3.0 is BBB, > 3.0 is Junk).
Drafting the Code (Mental Check):
- Need to handle the case where cutting dividends isn't enough (insolvency risk).
- Need to differentiate between "Target" and "Actual" payout.
- The "Decision Pack" should be a specific section in the Streamlit app showing "Headroom" (how much room before a downgrade) and "Sensitivity" (how a 10% drop in EBITDA affects the dividend).
Polishing the Deliverable: The user asked for a "CFO/Board decision pack." I should structure the output of the code to look like one, maybe using distinct sections in the UI:
- Executive Summary: Recommendation (Hold, Grow, Cut).
- The Matrix: A grid of scenarios (Bull, Base, Bear).
- Guardrail Status: Traffic light system (Green/Amber/Red).
Let's write the Python code using Streamlit because it creates a web-app interface which fits "simulator" perfectly.
Self-Correction during drafting:
- Initial thought: Just use Net Income.
- Correction: Dividends are often funded by Cash Flow, not just accounting profit. I should focus on FCF (Free Cash Flow) or EPS. Let's stick to EPS (Earnings Per Share) for the payout ratio but check leverage (Net Debt/EBITDA) for the guardrails, as that's standard for credit ratings.
Plan:
- Concept: Define the variables.
- Code: Streamlit app.
- Sidebar inputs (Financials, Targets, Constraints).
- Simulation loop.
- Visuals (Line charts for trends, Bar charts for distribution).
- "The Pack" (Dataframe summary).
- Explanation: How to interpret the results.
Let's generate the response. This is a comprehensive Python application using Streamlit to create an interactive Dividend Policy Simulator. This tool allows a CFO or Board Member to stress-test dividend sustainability against credit ratings and cash constraints.
Features included:
- Payout Targets: Slider inputs for base and stress scenarios.
- Leverage & Rating Guardrails: Automated check against Net Debt/EBITDA thresholds (e.g., if Leverage > 3.5x, Dividend is cut).
- Cash Runway: Simulation of cash accumulation/depletion over 5 years.
- CFO Decision Pack: A formatted executive summary table and visual dashboard.
Prerequisites
You will need Python installed. Run the following command to install necessary libraries:
pip install streamlit pandas numpy plotlyThe Python Code (
dividend_simulator.py)Save the code below into a file named
dividend_simulator.pyand run it in your terminal usingstreamlit run dividend_simulator.py.import streamlit as st import pandas as pd import numpy as np import plotly.graph_objects as go from plotly.subplots import make_subplots # --- Page Config --- st.set_page_config(page_title="Dividend Policy Simulator", layout="wide", page_icon="💰") # --- CSS Styling --- st.markdown(""" <style> .main-header {font-size: 28px !important; font-weight: bold; color: #1f4e79;} .sub-header {font-size: 20px; font-weight: bold; margin-top: 20px;} .metric-card { background-color: #f9f9f9; border-left: 5px solid #1f4e79; padding: 15px; border-radius: 5px; box-shadow: 2px 2px 5px #eeeeee; } </style> """, unsafe_allow_html=True) # --- Sidebar: Inputs --- st.sidebar.markdown("## ⚙️ Model Assumptions") with st.sidebar.expander("📈 Financial Baseline", expanded=True): net_income = st.number_input("Base Net Income ($M)", value=500, min_value=0) ebitda = st.number_input("Base EBITDA ($M)", value=800, min_value=0) current_debt = st.number_input("Current Gross Debt ($M)", value=2000, min_value=0) current_cash = st.number_input("Current Cash on Hand ($M)", value=500, min_value=0) with st.sidebar.expander("🎯 Payout Policy", expanded=True): payout_target = st.slider("Target Payout Ratio (%)", 0, 100, 40) buyback_pct = st.slider("Share Buybacks (% of Net Income)", 0, 50, 10) with st.sidebar.expander("🛡️ Guardrails & Constraints", expanded=True): st.markdown("**Credit Rating Triggers (Net Debt / EBITDA)**") rating_trigger_ig = st.slider("Investment Grade Limit (BBB)", 2.0, 4.0, 3.0, 0.1) rating_trigger_junk = st.slider("Speculative Limit (BB)", 3.0, 6.0, 4.5, 0.1) st.markdown("**Liquidity Constraints**") min_cash_balance = st.number_input("Minimum Cash Runway ($M)", value=200, min_value=0) with st.sidebar.expander("📉 Stress Test Scenario", expanded=False): enable_stress = st.checkbox("Enable Stress Test", value=True) ni_decline = st.slider("Net Income Decline (%)", 0, 50, 20) ebitda_decline = st.slider("EBITDA Decline (%)", 0, 50, 15) # --- Simulation Logic --- def run_simulation(base_ni, base_ebitda, base_debt, base_cash, payout, years=5): data = [] current_ni = base_ni current_ebitda = base_ebitda debt = base_debt cash = base_cash # Simple growth assumption for baseline (can be complexified) growth_rate = 1.02 for y in range(years): year_num = y + 1 # 1. Determine Earnings if enable_stress and y < 2: # Stress hits first 2 years eff_ni = current_ni * (1 - (ni_decline/100)) eff_ebitda = current_ebitda * (1 - (ebitda_decline/100)) else: eff_ni = current_ni eff_ebitda = current_ebitda # 2. Calculate Proposed Dividend proposed_div = eff_ni * (payout/100) # 3. Calculate Buybacks proposed_buyback = eff_ni * (buyback_pct/100) # 4. Apply Guardrails (The Logic Engine) leverage = (debt - cash) / eff_ebitda if eff_ebitda > 0 else 99 status = "✅ Fully Funded" actual_div = proposed_div # Guardrail A: Leverage if leverage > rating_trigger_junk: status = "🚨 FORCE CUT (Junk)" actual_div = 0 # Total cut to save rating elif leverage > rating_trigger_ig: status = "⚠️ PARTIAL CUT (Leverage)" actual_div = proposed_div * 0.5 # Cut in half to repair balance sheet # Guardrail B: Liquidity proj_cash = cash + eff_ni - actual_div - proposed_buyback if proj_cash < min_cash_balance: status = "❌ SUSPENDED (Cash)" actual_div = 0 # Must preserve cash # 5. Update Balances cash = cash + eff_ni - actual_div - proposed_buyback # Debt assumed constant for simplicity in this snippet, or add amortization schedule # Record Data data.append({ "Year": f"Y{year_num}", "Net Income": eff_ni, "EBITDA": eff_ebitda, "Proposed Div": proposed_div, "Actual Div": actual_div, "Buybacks": proposed_buyback, "Total Payout": actual_div + proposed_buyback, "Cash Balance": cash, "Net Leverage": leverage, "Status": status, "Payout %": (actual_div / eff_ni * 100) if eff_ni > 0 else 0 }) # Increment for next year (recovery/growth) current_ni *= growth_rate current_ebitda *= growth_rate return pd.DataFrame(data) # --- Run Calculation --- df_sim = run_simulation(net_income, ebitda, current_debt, current_cash, payout_target) # --- Dashboard Layout --- st.markdown("<h1 class='main-header'>Dividend Policy & Capital Allocation Simulator</h1>", unsafe_allow_html=True) st.markdown("Simulate dividend sustainability against earnings volatility and credit rating constraints.") col1, col2, col3, col4 = st.columns(4) with col1: st.metric("Y1 Net Income", f"${df_sim.iloc[0]['Net Income']:,.0f}M", delta=f"-{ni_decline}%" if enable_stress else None) with col2: st.metric("Y1 Leverage", f"{df_sim.iloc[0]['Net Leverage']:.2f}x", delta_color="inverse") with col3: st.metric("Y1 Dividend", f"${df_sim.iloc[0]['Actual Div']:,.0f}M", delta=f"{df_sim.iloc[0]['Payout %']:.1f}%") with col4: st.metric("Y5 Cash Balance", f"${df_sim.iloc[4]['Cash Balance']:,.0f}M") st.markdown("---") # --- Visualizations --- fig = make_subplots(rows=2, cols=2, subplot_titles=('Net Leverage vs. Guardrails', 'Cash Balance Runway', 'Dividend vs. Net Income', 'Capital Allocation Mix'), row_heights=[0.5, 0.5]) # Chart 1: Leverage fig.add_trace(go.Scatter(x=df_sim['Year'], y=df_sim['Net Leverage'], name='Net Leverage', line=dict(color='blue', width=3)), row=1, col=1) fig.add_trace(go.Scatter(x=df_sim['Year'], y=[rating_trigger_ig]*5, name='IG Limit', line=dict(color='orange', dash='dash')), row=1, col=1) fig.add_trace(go.Scatter(x=df_sim['Year'], y=[rating_trigger_junk]*5, name='Junk Limit', line=dict(color='red', dash='dash')), row=1, col=1) # Chart 2: Cash fig.add_trace(go.Bar(x=df_sim['Year'], y=df_sim['Cash Balance'], name='Cash', marker_color='green'), row=1, col=2) fig.add_trace(go.Scatter(x=df_sim['Year'], y=[min_cash_balance]*5, name='Min Cash', line=dict(color='black', dash='dot')), row=1, col=2) # Chart 3: Div vs NI fig.add_trace(go.Bar(x=df_sim['Year'], y=df_sim['Net Income'], name='Net Income', marker_color='lightgrey'), row=2, col=1) fig.add_trace(go.Scatter(x=df_sim['Year'], y=df_sim['Actual Div'], name='Dividend', fill='tozeroy', line=dict(color='navy')), row=2, col=1) # Chart 4: Allocation fig.add_trace(go.Bar(x=df_sim['Year'], y=df_sim['Actual Div'], name='Div', marker_color='navy'), row=2, col=2) fig.add_trace(go.Bar(x=df_sim['Year'], y=df_sim['Buybacks'], name='Buyback', marker_color='cyan'), row=2, col=2) fig.update_layout(height=800, showlegend=False, title_text="Financial Projections & Policy Impact") st.plotly_chart(fig, use_container_width=True) # --- CFO Decision Pack --- st.markdown("<h2 class='sub-header'>📋 CFO Decision Pack</h2>", unsafe_allow_html=True) st.markdown("#### Simulation Table") # Format the dataframe for display df_display = df_sim.copy() cols_to_format = ['Net Income', 'EBITDA', 'Proposed Div', 'Actual Div', 'Buybacks', 'Total Payout', 'Cash Balance'] for col in cols_to_format: df_display[col] = df_display[col].map('${:,.0f}M'.format) df_display['Net Leverage'] = df_display['Net Leverage'].map('{:.2f}x'.format) df_display['Payout %'] = df_display['Payout %'].map('{:.1f}%'.format) st.dataframe(df_display.set_index('Year'), use_container_width=True) st.markdown("#### Board Recommendation") if (df_sim['Status'] == "✅ Fully Funded").all(): st.success("✅ **Recommendation:** Maintain current dividend policy. The balance sheet absorbs stress scenarios while retaining Investment Grade rating.") elif (df_sim['Status'] == "❌ SUSPENDED (Cash)").any(): st.error("❌ **Recommendation:** SUSPEND Dividend. Liquidity constraints breached. Prioritize cash preservation.") elif (df_sim['Status'] == "🚨 FORCE CUT (Junk)").any(): st.warning("⚠️ **Recommendation:** CUT Dividend significantly. Risk of credit downgrade to Junk status. De-leveraging required.") elif (df_sim['Status'] == "⚠️ PARTIAL CUT (Leverage)").any(): st.info("ℹ️ **Recommendation:** REDUCE Dividend. Temporary breach of Investment Grade comfort zone. Moderate cuts required to repair leverage ratio.") else: st.info("ℹ️ **Recommendation:** Monitor closely. No immediate cuts required, but headroom is tightening.") st.markdown("---") st.markdown("*Disclaimer: This model is for educational and simulation purposes only. It assumes debt principal remains constant and does not model interest rate fluctuations.*")How to use the tool:
- Run the App: Open your terminal/command prompt, navigate to the folder where you saved the file, and run:
streamlit run dividend_simulator.py - Configure Baseline: In the sidebar, input your company's current financials (Net Income, Debt, Cash).
- Set Policy: Choose your target Dividend Payout Ratio and Buyback percentage.
- Define Guardrails: Set the "Tripwires."
- IG Limit: The leverage ratio where you want to stop behaving like a pristine investment-grade company.
- Junk Limit: The leverage ratio where you panic to save the balance sheet.
- Min Cash: The absolute minimum cash balance allowed.
- Run Stress Test: Toggle the "Enable Stress Test" to simulate a recession (e.g., a 20% drop in Net Income) and watch how the Status column in the table changes from "Fully Funded" to "Force Cut."
Key Logic in the Simulation:
- The "Junk" Trigger: If Net Leverage exceeds the "Speculative Limit" (e.g., 4.5x), the simulator automatically sets the dividend to $0. This reflects reality where a company must stop cash outflow to avoid defaulting on covenants or getting downgraded to 'B' status.
- The "Cash Trap": Even if earnings are good, if the ending cash balance falls below your minimum runway requirement, the dividend is suspended to preserve liquidity.
- The Decision Pack: The bottom table provides the exact output a CFO would present to the Board, showing not just the numbers, but the status of the dividend year-over-year.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.