Create app.py

app.py

@@ -0,0 +1,156 @@
+import gradio as gr
+
+# --- Calculation Logic ---
+
+def format_currency(value):
+    """Formats a number into a currency string."""
+    if value is None:
+        return "$0.00"
+    return f"${value:,.2f}"
+
+def calculate_arr_valuation(arr, yoy_growth, nrr, ebitda, base_multiple):
+    """
+    Calculates SaaS valuation based on an adjusted ARR multiple.
+    V = ARR * (Base Multiple * Growth Factor * Retention Factor * Efficiency Factor)
+    """
+    if not all(isinstance(i, (int, float)) for i in [arr, yoy_growth, nrr, ebitda, base_multiple]) or arr <= 0:
+        return "Please provide valid inputs for all fields.", "$0.00"
+
+    # Convert percentages from 0-100 scale to decimal for calculations
+    g = yoy_growth / 100.0
+    nrr_decimal = nrr / 100.0
+    ebitda_margin = ebitda / arr
+
+    # --- Model Constants and Benchmarks ---
+    w_g = 0.30  # Growth Factor Weight
+    w_r = 0.50  # Retention Factor Weight
+    w_e = 0.20  # Efficiency Factor Weight
+    g_b = 0.40  # Benchmark YoY Growth (40%)
+    nrr_b = 1.05  # Benchmark NRR (105%)
+    r40_b = 0.40  # Benchmark Rule of 40
+
+    # 1. Calculate Growth Factor
+    f_growth = 1 + w_g * ((g - g_b) / g_b)
+
+    # 2. Calculate Retention Factor
+    f_retention = 1 + w_r * ((nrr_decimal - nrr_b) / nrr_b)
+
+    # 3. Calculate Efficiency Factor (based on Rule of 40)
+    rule_of_40_score = g + ebitda_margin
+    f_efficiency = 1 + w_e * ((rule_of_40_score - r40_b) / r40_b)
+
+    # Calculate the final adjusted multiple
+    m_adj = base_multiple * f_growth * f_retention * f_efficiency
+    
+    # Apply a reasonable cap/floor to the adjusted multiple to avoid extreme results
+    m_adj = max(1.0, min(m_adj, 50.0))
+
+    # Calculate the final valuation
+    valuation = arr * m_adj
+
+    # --- Create summary text for display ---
+    summary_text = (
+        f"Base Multiple: {base_multiple:.2f}x\n"
+        f"YoY Growth Factor Adj: {f_growth:.2f}x\n"
+        f"Net Revenue Retention Factor Adj: {f_retention:.2f}x\n"
+        f"Efficiency (Rule of 40) Factor Adj: {f_efficiency:.2f}x\n"
+        f"--------------------------------------\n"
+        f"Final Adjusted Multiple: {m_adj:.2f}x"
+    )
+
+    return summary_text, format_currency(valuation)
+
+
+def calculate_simple_valuation(financial_metric, multiple):
+    """Calculates a simple valuation (Metric * Multiple)."""
+    if not all(isinstance(i, (int, float)) for i in [financial_metric, multiple]):
+        return "$0.00"
+    valuation = financial_metric * multiple
+    return format_currency(valuation)
+
+# --- Gradio UI ---
+
+# CSS for styling the output boxes
+css = "#valuation_output { font-size: 24px; font-weight: bold; color: #1d4ed8; text-align: center; }"
+
+with gr.Blocks(title="SaaS Valuation Calculator", css=css) as demo:
+    gr.Markdown(
+        """
+        # SaaS Business Valuation Calculator
+        Estimate the market value of a SaaS business using three common valuation models.
+        Adjust the sliders and inputs to see how different metrics affect the final valuation in real-time.
+        """
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("Comprehensive (ARR-Based)"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("### Core Financials")
+                    arr_input = gr.Number(label="Annual Recurring Revenue (ARR)", value=2_000_000, step=10000)
+                    yoy_growth_input = gr.Slider(minimum=0, maximum=200, value=50, step=1, label="YoY Growth (%)")
+                    nrr_input = gr.Slider(minimum=70, maximum=150, value=110, step=1, label="Net Revenue Retention (NRR %)")
+                    ebitda_input = gr.Number(label="EBITDA (for Rule of 40)", value=-100_000, step=10000)
+                    base_multiple_input = gr.Slider(minimum=1, maximum=20, value=7, step=0.5, label="Market Base Multiple")
+
+                with gr.Column(scale=1):
+                    gr.Markdown("### Calculation Breakdown")
+                    summary_output = gr.Textbox(label="Adjusted Multiple Calculation", lines=6, interactive=False)
+                    gr.Markdown("<br>",)
+                    arr_valuation_output = gr.Textbox(label="Estimated Valuation", interactive=False, elem_id="valuation_output")
+            
+            arr_inputs = [arr_input, yoy_growth_input, nrr_input, ebitda_input, base_multiple_input]
+            arr_outputs = [summary_output, arr_valuation_output]
+            for component in arr_inputs:
+                component.change(fn=calculate_arr_valuation, inputs=arr_inputs, outputs=arr_outputs)
+
+        with gr.TabItem("EBITDA Multiple"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown(
+                        """
+                        ### EBITDA-Based Valuation
+                        A straightforward model typically used for mature, profitable companies where earnings are a key indicator of value.
+                        """
+                    )
+                    ebitda_simple_input = gr.Number(label="EBITDA", value=500_000, step=10000)
+                    ebitda_multiple_input = gr.Slider(minimum=1, maximum=25, value=10, step=1, label="EBITDA Multiple")
+
+                with gr.Column():
+                    ebitda_valuation_output = gr.Textbox(label="Estimated Valuation", interactive=False, elem_id="valuation_output")
+            
+            ebitda_inputs = [ebitda_simple_input, ebitda_multiple_input]
+            for component in ebitda_inputs:
+                component.change(fn=calculate_simple_valuation, inputs=ebitda_inputs, outputs=ebitda_valuation_output)
+
+        with gr.TabItem("SDE Multiple"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown(
+                        """
+                        ### SDE-Based Valuation
+                        Common for smaller, owner-operated businesses. SDE adds back the owner's salary and other discretionary expenses to net profit to show the full cash flow benefit to a single owner.
+                        """
+                    )
+                    sde_input = gr.Number(label="Seller's Discretionary Earnings (SDE)", value=300_000, step=5000)
+                    sde_multiple_input = gr.Slider(minimum=1, maximum=10, value=4, step=0.5, label="SDE Multiple")
+                with gr.Column():
+                    sde_valuation_output = gr.Textbox(label="Estimated Valuation", interactive=False, elem_id="valuation_output")
+
+            sde_inputs = [sde_input, sde_multiple_input]
+            for component in sde_inputs:
+                component.change(fn=calculate_simple_valuation, inputs=sde_inputs, outputs=sde_valuation_output)
+    
+
+    # Trigger initial calculations on load
+    demo.load(
+        fn=calculate_arr_valuation, inputs=arr_inputs, outputs=arr_outputs
+    ).then(
+        fn=calculate_simple_valuation, inputs=ebitda_inputs, outputs=ebitda_valuation_output
+    ).then(
+        fn=calculate_simple_valuation, inputs=sde_inputs, outputs=sde_valuation_output
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()