Configuration
The line between what you configure and what only a developer changes is drawn on purpose, and it sits far towards configuration.
Too much configuration, then too much code
Most IT teams in financial services have lived through one of two things. Either the system can be configured to do almost anything, but the configuration is so complex that only the vendor can touch it, or every customer has had their own changes coded in until there's a separate version for each of them. We've lived through both, with our own software.
The first CreditPlus, in 1999, was a highly configurable engine. It could model some genuinely complex account structures, and one bank did exactly that, but it was well beyond what a customer could configure on their own. A complex engine also makes for a poor screen: "reset the rate" turns into "add an accrual rule", which is not how anyone in the business thinks. And underneath sat a database of hundreds of normalised tables that had to be loaded into memory before every day-end, or the reads per account would have been enormous.
The rewrite for New Zealand went the other way. We were under pressure to deliver for several clients at once, so we cut corners and went back to custom code over configuration, and that came back to bite us with a version per client and a core much smaller than it should have been.
LedgerTM sits in the middle on purpose. A scripting engine handles configured calculations, which is far simpler than trying to model every one of them as a rigid data structure. Settings are documents rather than tables, so there's no wall of joins to fight at day-end. And the line between what a bank configures and what only a developer changes is drawn deliberately, a long way over towards configuration.
| Configuration: a settings row, versioned, per tenant | Code: the engine |
|---|---|
| Account types: positions, transaction types, schedules, input amounts | How a position is posted and accrued |
| Rate cards, banded by period and amount; day-count conventions | Interest arithmetic and rounding |
| Calendars and business-day conventions | Date arithmetic |
| Posting groups and posting rules per operating entity | Double entry and period close |
| Workflow steps and which operations need four eyes | The authorisation mechanism |
| Permissions per role | Deny by default |
| Counterparty, relationship, role and collateral types | The aggregate model |
| Capabilities switched on per tenant | The capabilities themselves |
| Numbering schemes, statement layouts, submission formats | Rendering and transport |
# One account type, excerpted from the retail lending template.
- accountType:
name: PersonalLoan
label: Personal Loan
productFamily: Loans
nature: Asset
collectionMethod: DirectDebit
positionTypes:
- name: Balance
- name: Accrued
- name: Arrears
- name: Provision
transactionTypes:
- name: Advance
isPostable: true
paymentInstruction: DirectCredit
positionRules:
- operation: Debit
positionTypeName: Balance
- name: InterestAccrued
costOfCreditCategory: Interest
positionRules:
- operation: Debit
positionTypeName: Accrued
scheduleTypes:
- name: Accrual
frequency: Daily
businessDayConvention: None
startDateExpression: StartDate
endDateExpression: EndDate
- name: Anniversary
frequency: Monthly
businessDayConvention: ModifiedFollowing
startDateExpression: FirstPaymentDate
endDateExpression: EndDate
scheduledTransactions:
- name: DailyAccrual
scheduleName: Accrual
timing: EndOfDay
generatedTransactionType: InterestAccrued
amountExpression: (Balance + Arrears) * rate(interestRate, valueDate) / daysInYear(valueDate)
conditionExpression: (Balance + Arrears) > 0
- name: AnniversaryServiceFee
scheduleName: Anniversary
timing: StartOfDay
generatedTransactionType: ServiceFeeCharged
amountExpression: price('service-fee', valueDate)
instalmentType:
name: Instalment
scheduleName: Anniversary
transactionType: InstalmentDue
solveForZeroPosition: Balance
solveForDate: EndDate
rateChangePolicy: ReSolve
openingTransactions:
- type: InitiationFeeCharged
amount: initiationFee
optional: true
- type: Advance
isAdvance: true
amount: loanAmountAn account type is a document you can read.
This is a personal loan from the retail bank template, cut down a little. Its positions, the transactions that move them, the schedules they run on, the expressions that price them and the instalment solver are all in there. A product manager can read it and the engine runs it as it stands, so a new product is just a new document.
The full version also carries the capture screens, the balance views, the statutory cost-of-credit categories and the operations a clerk is allowed to perform, all in the same file and the same shape.
Describe a new account type in plain English.
The designer reads the configuration model, drafts the account type, builds the capture screens in a sandbox and projects the transactions across the account's whole life. When the numbers are right it goes live while the system is running, without a line of code. Where else AI works in the product →

Configuration also makes commercial sense. Each capability can be switched on or off for a customer, so each one can be priced on its own. Products are set up rather than programmed, so a partner can build one for a market we've never worked in. And because a setting is a document anyone can read, an auditor can check exactly how a product behaves without asking a developer.
Bringing on a new product is a configuration exercise on a sandbox tenant, and the forecaster is how you test it.