Platform
For the team that has to run it, and has probably been burnt by a platform choice before.
We've bet on the wrong platform too
If you've ever built a product on a platform the vendor then walked away from, you'll know the feeling. We've been there, with Silverlight and later with Blazor, and both times we got burnt. So this time we chose boring, popular and open: .NET and C# for the engine, PostgreSQL for the data, React for the interface, and two well-used open-source libraries for the hard plumbing. Each of them has a large community behind it and isn't going anywhere.
And if one of them ever does go somewhere, it matters less than it used to. The design lives in the decision records and the behaviour is pinned down by thousands of tests, so with AI doing the work, replacing a piece of the stack is a project rather than a rewrite. We moved our own interface from Blazor to React in days.
C#
The engine, the API, the worker and the gateway are all one language in one solution, on .NET. Strongly typed identifiers and records do a lot of the checking that tests would otherwise have to do.
TypeScript
The interface, with React. Its API types are generated from the server's OpenAPI description, so a changed endpoint fails the interface build rather than a user.
YAML
Configuration, meaning account types, rate cards, calendars, posting rules, features and roles. It's readable by a person, versioned and easy to compare, and it's what the account designer writes.
An expression language of our own
Rates, fees, amounts and conditions inside configuration, such as (Balance + Arrears) * rate(interestRate, valueDate) / daysInYear(valueDate). It's compiled inside the engine with a fixed set of functions, and because it isn't a general-purpose scripting language it can't reach outside the account it's pricing.
SQL
PostgreSQL sits underneath, through the document and event store. Read models are queried directly rather than joined by hand across modules.
Gherkin, Markdown, shell
Acceptance scenarios are written as given, when, then. Decision records, guides and the rulebook are Markdown, and the gates and the build machine run on shell scripts.
These are two open-source .NET libraries, known together as the Critter Stack. They carry the plumbing so that our own code can concentrate on the banking.
Marten
A document database and event store on PostgreSQL. Every event is kept, and the read models are built from those events in the same transaction as the write, so a balance and its history can never disagree.
Wolverine
Messaging and command handling, where each command reaches exactly one handler. Retries, scheduled messages and long-running workflows come from the library rather than from code we'd have to write and maintain ourselves.
Transactional outbox
An event and every message it triggers are committed in one PostgreSQL transaction. If the write rolls back nothing is sent, and if the process stops after the commit the message is still delivered, so you never lose a posting or get one for a change that never happened.
CQRS
Commands change state through an aggregate, and queries read projections without ever touching one. The two paths are kept separate by design, and the build checks that every message says which kind it is.
Event sourcing and CQRS →Proven at scale
Marten passed 20 million NuGet downloads in September 2026, eleven years after its first commit. The next-closest .NET event store has just over 8 million. 257 people have contributed, and 2,275 pull requests have been merged.
The milestone →- A pull request runs the unit suitea quick two-minute check before anyone reads the code
- A land gates the integrated tree on the full suitebuild, unit, integration and interface checks, always before the merge and never after it
- A push to main builds and deploysfour images go to the registry, the interface is built, and staging is redeployed from a clean database and reseeded
- Migrations are proven on a fresh databaseon every push, in the pipeline, before they ever reach a real one
- Nightly, the full suite againand every release is tagged
Databases
PostgreSQL today. SQL Server is supported by the same family of libraries, but we haven't proven it ourselves yet, and we'll say so plainly if you ask.
Containers
Three services as containers: gateway, API and worker, built from one Dockerfile, plus a one-off migrations job that runs before each release starts. The interface is a static bundle served by the edge proxy, and the developer's local setup has the same shape as production.
Cloud or on-premises
It doesn't need any managed cloud service, and runs on any Kubernetes or on a pair of virtual machines, so a business that wants its data on its own floor can keep it there.
Scale
The engine's lineage ran a 6,700-account structured book for twenty-five years and a 100,000-account consumer book in New Zealand. The architecture is built for both shapes, a small complex book and a large retail operation. We learnt about performance the hard way at Brait, where a design with hundreds of tables took real work to make fast, so LedgerTM's performance and scalability testing happens before launch, and we'll publish the benchmarks when we have them.
Operations
Day-end runs per tenant with a full run log, logging and health checks come through .NET Aspire, and there's one database to back up and restore.
Recovery and support
Recovery targets belong to whoever runs LedgerTM, because they choose the infrastructure. What we make easy is meeting them: everything lives in one PostgreSQL database, so standard PostgreSQL backup and point-in-time recovery cover the lot, and every list and report can be rebuilt from the event stream. Support terms are agreed as part of each arrangement, directly or through a partner.