01
Code to Excel Translation
Model Developers build models in a programming language, then rewrite them in Excel just to communicate the formulas. They must prove both versions match before sharing.
All-in-one model lifecycle management.
Powering the risk models that drive the bank.
Stale or over-conservative models leave capital locked up longer than the risk requires. RiskFoundry shortens the path from a new formula to an approved model used in production, all with versioning, audit evidence, and governance captured as the work happens. Faster, more confident model updates lets capital follow the portfolio, freeing balance-sheet capacity for lending and investment.
Rating models underpin how a bank prices, lends, and holds capital.
Yet they are either managed in a slow, legacy platform, or in no platform at all.
A rating model travels a long road: exploration, review, validation, regulatory approval, production, monitoring. The same experts carry four efforts beside the modeling itself: translating the logic so each change can be explained, translating it again so production can run it, versioning the data used to test it, and producing the regulatory documentation from the explanations, versions, and approvals gathered along the way. Each time the model moves, that work is repeated.
02
Production Re-implementation
Those formulas are written again in the production system: another translation, another chance to diverge, which means another testing and validation round.
03
Scattered Model Versioning
The model is already versioned in several formats, each in its own files. Keeping a matching history of the datasets used to test it is a further effort. "Which version ran on which data, and when?" takes weeks to answer.
04
Disconnected Audit Sign-offs
Each approval or justification is kept where that step happens: a committee pack, an email, a meeting note. Pulling them onto the version they cover, and into the regulatory documentation, can take weeks when done by hand.
One platform for the entire model lifecycle.
RiskFoundry
Back-test Q12,000 records
DatasMapping+
#CREDITSCOREREVENUELTD_RATIOSECTORRATING
1 720 45 000 000 0.35 Technology
2 580 12 000 000 0.72 Energy
3 690 28 000 000 0.48 Healthcare
4 810 95 000 000 0.15 Technology
5 640 8 500 000 0.61 Energy
6 750 62 000 000 0.29 Healthcare
7 705 38 200 000 0.41 Industrials
8 660 14 750 000 0.55 Retail
9 775 41 300 000 0.27 Industrials
+ Add Row
1import numpy as np
2
3# weighted blend of module scores
4W = {"financial": 0.45, "qualitative": 0.40, "systemic": 0.15}
5
6def module_score(beta, woe):
7 return beta[0] + beta[1:] @ woeSophie
8
9def final_score(x):
10 return sum(W[m] * module_score(B[m], x[m]) for m in W)
1from sklearn.linear_model import LogisticRegression
2
3def fit_woe(df, target):
4 enc = WoEEncoder().fit(df, target)
5 return enc.transform(df)
6
7def calibrate(X, y):
8 return LogisticRegression().fit(X, y)
1model: large_corporate_lgd
2version: 2.1.0
3weights:
4 financial: 0.45
5 qualitative: 0.40
6 systemic: 0.15
SB
Sophie BernardCap β at 3·σ before the matmul?
Panel ReviewIn Progress· Assigned to Jean Martin2
Started the validation workflow at Draft.
Initial model documentation is ready for review.
Moved to Panel Review.
panel-review-checklist.pdf197 kb
@Marie Dupont please confirm the back-testing window before the panel.
Back-testing reproduced ✓ — checklist updated, opening it now.
Panel Review Checklist
Model: Large Corporate LGD — v2.1.0
Reviewer: Validation Panel
Date: 23/04/2026
1. Documentation complete ········· OK
2. Data lineage verified ·········· OK
3. Assumptions challenged ········· OK
4. Back-testing reproduced ········ OK
5. Limitations documented ········· OK
Outcome: Cleared for Internal Validation.
PDF · Page 1 of 1 · mock preview
RiskFoundry is where a model lives from first idea to live production and every change, version, dataset, justification, and approval is captured automatically as it happens. It connects to the bank's data sources, takes its own versioned copies, runs the models, and produces validation and regulatory reports off the shelf.
No more translation tax. No more reconstructing the audit trail. The model the developer submits and gets approved is the model that runs in production.
Two ways RiskFoundry changes the game
A unified platform built to bridge the gap between model development and operational production.
Pillar 01
Build once, run in production. No translation in between.
The functions model developers author are the very functions tested, validated, and deployed straight through to production. No Excel hand-off, no separate re-implementation to validate later.
scorecard.py calibrate.py
1# β₀ + Σ βᵢ · WoEᵢ
2module_score = lambda beta, woe: beta[0] + beta[1:] @ woe
3
4def final_score(x):
5 return (0.45 * module_score(B_fin, x.fin)Amine
6 + 0.40 * module_score(B_qual, x.qual)
7 + 0.15 * module_score(B_sys, x.sys))
main Python 3.11 Ln 5, Col 38 2 live
Faster model production
Weeks of rewriting and reconciliation simply disappear.
No divergence by construction
What is approved is what runs, it is the same logic end to end.
Ready at approval
Nothing remains for IT to build, and no further round to prove a translation matches.
Experts freed for analysis
Developers diagnose and improve models instead of transcribing them.
Pillar 02
Traceability and audit, built in automatically.
Governance isn't a deliverable you assemble after the fact: it's a by-product of doing the work. Every version, change, dataset, and approval is captured and connected in one place.
MD
Marie DupontApr 21
Initial model documentation is ready for review.
Marie Dupont moved this to Panel Review · Apr 22
JM
Jean MartinApr 23
validation-notes.md4 kb
JM
Jean MartinApr 23
@Marie Dupont confirm the back-testing window before the panel.
Model and data versioning
Know which model version ran on which dataset version, and what that run produced, on any date.
Connected to your data sources
Read from the bank's data lake and store versioned copies, keeping tests always reproducible.
Reporting from the record
The author directs the validation or regulatory report, drawing its test outputs, formulas, and approvals from the system.
Workflows and sign-off evidence
Who changed what, who approved it, and why a version moved to the next stage is tracked as it happens.
The full lifecycle, in one place
RiskFoundry carries one model from a formula to a live rating. Each stage asks something new of it.
def pd_model(financials):
ebitda = financials.ebit
debt = financials.total_debt
return ebitda / debt
RT
Is the debt ratio properly weighted here?
QT
Yes — aligned with Basel III guidelines.
✓ Unit tests passed
✓ Backtesting passed
✓ Reg. documentation generated
Submit to regulator
POST /api/v1/models/pd/score 200
"score": 0.0142,
"rating": "A-"
PD performance 98.2%
tracked vs actual default rates
Why it matters to the bank
Faster, more confident model updates let capital follow the portfolio, and the gain is different at each desk that touches the model.
For the CRO & CFO
Regulatory capital moves closer to the real risk. As risk-weighted assets come down, the CET1 ratio improves mechanically, without raising new capital.
Validation & MRM
The formulas, the test runs, the data, and the approvals are in one central place. Reviews are easier, because comments and documents stay on the version under discussion.
Developers & Risk Analysts
Their focus goes to the model, and to whether the change holds on the book. The Excel copy and the production rewrite are no longer necessary.
Monitoring Teams
Actual defaults and analyst overrides are captured for the version currently in production. Those figures feed the monitoring report, so the review can focus on whether the model has shifted and an update is due.
IT & Enterprise Architecture
Model management sits apart from the credit-risk interface. Projects are shorter, deployments more certain, and IT moves from model testing to infrastructure, security, and development.
Why production execution sits with the lifecycle
Craft It implements credit-risk models and processes for banks, with over 60 years of combined experience helping banks around the world carry their risk with the right tools. We have learned that a model has a lifecycle with needs of its own and that it makes sense to separate the system that executes the model’s calculations in production from the interface where the analyst rates and approves the scores. The further step is to integrate that system with the one that manages the model’s lifecycle, whether the engine sits inside it or is tightly integrated with it.
Why independence matters
A bank rarely has one system executing its models. Pricing, lending, and capital may each call a different engine, and those engines change. RiskFoundry is the place that stays, run on-premises or in the bank’s own cloud. The data, the logic, the versions, and the proof remain the bank’s, under its control, whichever engine ran the calculation.
One place that stays
Inside the bank
The bank’s data
Under the bank’s control
Let's talk about your models.
Book a short meeting with the product team. See RiskFoundry in action: how it would run in your bank, and how it manages your models. Come with questions. Nothing to prepare, and nothing to decide on the call.