@dataclass(frozen=True)
class Adjustments:
    base_change: float = 0.0
    urban_factor: float = 1.0
    non_urban_factor: float = 1.0
    young_factor: float = 1.0      # drivers under 25
    sports_factor: float = 1.0
    cap: float | None = None       # e.g. 0.25
    expense_ratio: float = 0.25

def reprice(book, adj):
    b = book
    factor = ((1 + adj.base_change)
        * np.where(b.urban, adj.urban_factor,
                   adj.non_urban_factor)
        * np.where(b.driver_age < 25, adj.young_factor, 1)
        * np.where(b.vehicle_style == "Sports",
                   adj.sports_factor, 1))
    if adj.cap is not None:
        factor = np.clip(factor, 1 - adj.cap, 1 + adj.cap)
    out = b.assign(proposed_liab=(b.liab_premium * factor).round(2))
    out["change"] = out.proposed_liab / out.liab_premium - 1
    return out

import streamlit as st

st.title("Executive Underwriting Portal")

with st.sidebar:
    urban = st.slider("Urban factor", 0.70, 1.50,
                      step=0.01, key="urban_factor")
    ...

priced = reprice(book(), Adjustments(urban_factor=urban, ...))
s = summary(priced)

c1, c2, c3, c4 = st.columns(4)
c1.metric("Liability premium",
          f"${s['proposed_premium'] / 1e6:,.2f}m",
          f"{s['premium_change']:+.1%}")
c2.metric("Projected loss ratio", ...)

@st.cache_resource            # one per process: connections, models
def database():
    return db.make_engine(settings.sqlalchemy_url())

@st.cache_data(ttl=600)       # a copy per call: data frames
def book() -> pd.DataFrame:
    return db.read_book(database())

# session_state: this user's memory across reruns
st.session_state.setdefault("scenarios", [])
if st.button("Save this scenario", key="save"):
    st.session_state["scenarios"].append({...})

# a link can choose the starting point: ?preset=...
wanted = st.query_params.get("preset", "Current rates")

upload = st.file_uploader("Quote requests (CSV)", type="csv")
if upload is not None:
    raw = pd.read_csv(upload, dtype=str, keep_default_na=False)
    good, bad = [], []
    for row in raw.to_dict(orient="records"):
        try:
            good.append(QuoteRequest.model_validate(...))
        except ValidationError as exc:
            bad.append({"quote_id": ..., "problem": ...})
    st.dataframe(pd.DataFrame(bad))
    if settings.api_url:                  # in production
        quotes = RatingClient(settings.api_url, key) \
                     .quote_batch([r.model_dump(mode="json")
                                   for _, r in good])
    ...
    st.download_button("Download priced quotes",
                       csv_text, "priced_quotes.csv")

from streamlit.testing.v1 import AppTest

def test_moving_a_slider_reprices_the_book(app):
    app.slider(key="urban_factor").set_value(1.25).run()
    assert metric(app, "Liability premium").delta.startswith("+")
    assert metric(app, "Projected loss ratio").delta.startswith("-")

def test_preset_and_saved_scenarios(app):
    app.selectbox(key="preset").set_value(
        "Rate review proposal").run()
    assert app.slider(key="urban_factor").value == 1.25
    app.button(key="save").click().run()
    app.slider(key="base_change").set_value(5).run()
    app.button(key="save").click().run()
    assert len(app.session_state["scenarios"]) == 2

def test_a_link_can_choose_the_preset(...):
    at.query_params["preset"] = "Rate review proposal"
    ...

• The numbers are pure functions with their own tests
• The page is a thin layer that calls them
• Expensive things are cached, correctly scoped
• Per-user memory lives in session_state

• Uploads are validated before anything is priced
• The portal prices through the same API as everyone else
• The trade-off between adequacy and disruption is on screen
• AppTest checks the app without a browser