Configuration

The line between what you configure and what only a developer changes is drawn on purpose, and it sits far towards configuration.

We've built it both ways

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 or code
Configuration: a settings row, versioned, per tenantCode: the engine
Account types: positions, transaction types, schedules, input amountsHow a position is posted and accrued
Rate cards, banded by period and amount; day-count conventionsInterest arithmetic and rounding
Calendars and business-day conventionsDate arithmetic
Posting groups and posting rules per operating entityDouble entry and period close
Workflow steps and which operations need four eyesThe authorisation mechanism
Permissions per roleDeny by default
Counterparty, relationship, role and collateral typesThe aggregate model
Capabilities switched on per tenantThe capabilities themselves
Numbering schemes, statement layouts, submission formatsRendering and transport
What configuration looks like
# 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: loanAmount

An 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.

The account designer

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 →

The AI-assisted account designer
The account designer.
Why this matters commercially

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.