§ Platform - Program Studio

A loan program is a configuration, not a build.

Program Studio turns a lender's collection, credit policy, and memo standards into deployable Loan Programs. Each program binds the defaults its projects should inherit, while CORE supplies the configurable underwriting engine beneath them. Even the memo is a configuration.

Walk through Program Studio See CORE Credit Memos

Program configuration

LOAN PROGRAM · USDA B&I

BASE PACKAGEB&Iv6.0

ACTIVE

MEMO TEMPLATEUSDA OneRD Full Credit Memov62

DEFAULT

UNDERWRITING POLICYUSDA OneRD — Existing Businessv3.1

PUBLISHED

GOVERNING REGULATIONSUSDA OneRD regulatory set1 base

SET

One Loan Program binds the defaults each project inherits.

A Loan Program carries an active Base Package, Memo Template, Underwriting Policy, and, when applicable, a Governing Regulations source set. New projects inherit that governed starting point without hardcoding the platform around a product or capital source.

ONE ENGINE - GOVERNMENT-GUARANTEED, FARM CREDIT, CDFI, AND PRIVATE-CREDIT PROGRAMS

§ Program Studio Surfaces

Four surfaces configure what every project inherits.

Loan Programs

Loan Programs are the decision surface. Each one shows its Base Package, Memo Template, Underwriting Policy, and, when applicable, Governing Regulations before release into production.

CONFIGURATION MAPLoan Program configuration

The Loan Program is the binding record. Governing Regulations are configured when an external rule set applies.

Collection Packages

Reusable Collection Items are organized in the library and selected into packages. Each Loan Program has one active Base Package; optional global Add-on Packages add project-specific requirements during setup or release.

CONFIGURATION FLOWCollection deployment

Base Package binds to the program. Add-ons join only when the project needs them.

Underwriting Policies

Metrics, covenants, scorecard factors, thresholds, and risk treatment are assembled into governed policy versions. Published versions are immutable; programs bind defaults and deals retain replayable snapshots.

GOVERNED POLICY FLOWVersion to decision

The memo consumes the recorded policy result; it does not recalculate policy independently.

Memo Templates

Templates define sections, analytical intents, regulatory coverage, mandates, and output structure. Locked and flexible H1-H4 rules control which headings stay fixed and where the template may adapt.

§ Product Surface

The memo template carries the section logic.

CORE Program Studio intent matrix mapping memo sections to analytical intents — Product view · Intent Map - memo sections mapped to primary and secondary analytical intents.

CORE Program Studio domain coverage matrix showing regulatory domain coverage by memo section — Product view · Intent Map - memo sections mapped to primary and secondary analytical intents.

§ Fit

What unlocks with each product

Program Studio is the configuration layer behind the lifecycle, but not every studio is sold the same way.

CORE Workflow includes Loan Programs and Collection Packages for file, portal, collection, and workflow configuration

CORE Underwriting includes Underwriting Policies, credit-box configuration, COREView, and the evidence-to-judgment workspace

CORE Credit Memos adds program-specific memo analysis, Memo Templates, and human-in-the-loop AI support

Published versions are immutable; deals bind a snapshot that can be replayed later

Policy can be switched mid-deal when the lender or capital source changes, with the new snapshot preserved

§ Path

How a new program goes live

Assemble

Credit experts configure the Base Package, memo template, published policy, and applicable governing sources from controlled catalogs and libraries.

Bind

The Loan Program records the active package, memo and policy defaults, and any applicable Governing Regulations work should inherit.

Deploy

Projects created under the program inherit the configuration; workflows release in stages.

Version

Published policy and template changes create new versions. Existing deals retain the snapshots they were decided under.

§ In Depth

Configurable underwriting: why a loan program should never be an engineering project.

The build-per-program model is why lending software stagnates

In legacy platforms, supporting a new loan program means a vendor engagement: requirements, custom development, quarters of waiting. The result is that lenders run the programs their software shipped with, not the programs their market wants. Program Studio inverts that: collection packages, underwriting policies, and memo templates are configuration surfaces that credit experts assemble in weeks.

Four studios, one governed chain

Loan Programs bind the pieces together; Collection Packages define what must be gathered, entity by entity; Underwriting Policies move from reusable catalogs through editable drafts to immutable published versions; Memo Templates define the output structure, section by section. A deal underwrites against a snapshot of the published configuration — so the configuration that governed a decision is always recoverable, exactly as it stood.

Configurability is what makes the platform program-agnostic

Government-guaranteed programs, conventional bridge lending, private credit strategies, and specialty programs run on the same engine because their differences — documents, policies, memo structure, regulatory context — live in configuration, not code. Waterside's own operating configurations include SBA, USDA, and a conventional bridge program: the proof that the engine is not welded to one program family.

The underwriting workspace the configuration governs Memo templates in action: CORE Credit Memos

§ Next Step

Bring the program you thought was too bespoke for software.

Your credit process is something you can open and read, not something compiled into someone else's software.

Walk through Program Studio See CORE Credit Memos