Kobble Core
The programmable financial engine beneath everything we do. Real-time, double-entry, multi-entity ledger with native sub-ledger architecture, programmable controls, and compliance at the transaction level. 30 core capabilities. Zero legacy code. Built in Australia.
Ledger Architecture
The foundation everything runs on.
Real-Time Double-Entry Ledger
Every transaction posted as balanced debit/credit pair in real-time. No batch windows, no overnight processing.
Why: Batch processing is the #1 source of balance discrepancies in legacy systems.
Deterministic Posting
Same inputs always produce same outputs. No race conditions.
Why: High-volume card programs can't afford non-deterministic behaviour in their ledger.
Immutable Journal with Cryptographic Integrity
Append-only, hash-chain verified. Entries can only be reversed, never altered.
Why: Regulators and auditors require tamper-proof records. This is the standard they're moving toward.
Temporal & Audit
See everything. At any point in time.
Temporal State Reconstruction
Query any account's state at any historical moment.
Why: Regulatory inquiries and dispute resolution require historical state access. Most platforms can't do this natively.
Complete Event-Driven Audit Trail
Every state change captured as an immutable event, streamed in real-time.
Why: AUSTRAC and scheme compliance require comprehensive trails. No gaps, no reconstructions.
Independent Audit-Read Replicas
Read-only access for regulators and auditors, isolated from production.
Why: Auditors shouldn't query your production database. Replicas give full visibility with zero risk.
Account Model
Every entity. Every structure. One framework.
Unified Individual & Corporate Account Framework
One model for consumers, corporates, trusts, government. No separate systems.
Why: Clients serving both consumers and businesses don't want two different platforms.
Hierarchical Parent-Child Accounts
Native sub-ledger architecture, unlimited nesting depth. Corporate → Division → Department → Employee.
Why: Real corporate banking requires hierarchical structures. Flat account models force workarounds.
Virtual Accounts at Scale
Thousands per parent entity, API-created in milliseconds. Own reference, balance, history, controls.
Why: Modern treasury, marketplace, and platform businesses depend on virtual accounts. Per-account charges kill the economics.
Identity & Access
Control who does what, down to the action.
Delegated Authority with Role-Based Permissions
Configurable per account, per user, per action type.
Why: For SME banking, treasury, and multi-user business accounts — delegated authority is a regulatory requirement, not a feature.
Maker-Checker Transaction Governance
Dual authorisation for high-value/high-risk transactions. Configurable thresholds.
Why: Every bank, insurer, and corporate treasury requires this as baseline internal control.
Beneficial Ownership Mapping
Model ownership structures (directors, shareholders, UBOs) at the account level.
Why: KYB requirements are tightening. Platforms that don't model ownership structurally force compliance into spreadsheets.
Programmable Controls
A ledger that behaves like software.
Rule-Based Transaction Engine
Evaluate every transaction in real-time against configurable rules before posting.
Why: Turns a ledger into a platform. Clients want to control transactions, not just record them.
Dynamic Spending Controls
Per-card, per-account limits by MCC, geography, time window, merchant. Updated in real-time via API.
Why: Expense management, salary packaging, and fleet cards all depend on fine-grained spending controls.
Programmable Velocity Controls
Transaction count, cumulative amount, and frequency thresholds over configurable time windows.
Why: First line of fraud defence. Programmable via API means clients tune controls for their risk profile.
Balance Management
Intelligent money at the account level.
Smart Balance Partitioning
Automatically partition balances into labelled sub-balances: tax, savings, escrow, available, held, or custom.
Why: How neobanks build savings pots, salary packaging separates categories, and marketplaces hold escrow.
Automated Sweep Logic
Auto-move balances between accounts or partitions on triggers: threshold, schedule, time, or event.
Why: Treasury management and interest optimisation depend on sweep logic. Native = no external schedulers.
Programmable Fees & Revenue Splits
Flat, percentage, tiered, or custom formulas. Multi-party splits calculated at the ledger level.
Why: Every BaaS business model involves fees and revenue sharing. If it's not in the ledger, it leaks.
Money Movement
Move money anywhere. Any rail. Optimised.
Wallet-to-Wallet Instant Transfers
Internal transfers settle atomically. Both sides update in the same transaction. Zero cost.
Why: Highest-volume, lowest-cost rail for marketplace and platform money movement.
Multi-Rail Routing Optimisation
Engine selects optimal outbound rail: lowest cost, fastest settlement, or specific preference.
Why: Different rails have different costs and speeds. Smart routing saves money at scale.
Bulk Disbursement Engine
Thousands of outbound payments in a single API call. Mixed rails. Real-time status per payment.
Why: Payroll, insurance, and marketplace payouts all need bulk disbursement. Can't afford bottlenecks.
Atomic Cross-Rail Transactions
Multi-leg transactions execute all-or-nothing. No partial postings. No orphaned transactions.
Why: Partial failures are the most expensive operational incidents in financial platforms. Atomic execution eliminates them.
Compliance & Risk
Compliance at the core. Not bolted on.
Ledger-Native AML Monitoring Hooks
Embedded at the transaction processing layer. Real-time scoring, not end-of-day batch.
Why: AUSTRAC expects real-time monitoring. Batch analysis is already behind regulatory expectations.
Automated Reconciliation Framework
Continuous reconciliation between ledger and external systems. Discrepancies flagged in real-time.
Why: Manual reconciliation is the largest operational cost in most payment businesses.
Safeguarding & Client Money Reporting
Real-time views for AFSL-compliant client money segregation. Balance attestation for independent verification.
Why: AFSL holders have strict client money obligations. Real-time proof beats monthly reconstruction.
Account Lifecycle
Accounts that adapt to their context.
Programmable Account States
Active, frozen, restricted, suspended, dormant, closed. Each state enforces different rules. Triggered manually, by rule, or by event.
Why: Regulatory requirements (dormancy, sanctions freezes, deceased handling) enforced at the ledger, not in application code.
Embedded KYC/KYB Status Hooks
Account behaviour adapts based on verification status. Limits lift on completion, restrictions re-engage on expiry.
Why: Tiered KYC is how BaaS programs work. Zero gap between verification status and account behaviour.
Omnibus & FBO Account Modelling
For Benefit Of structures with individual sub-accounts within pooled accounts. Segregation reporting included.
Why: FBO is the standard structure for BaaS under a bank partner's licence. Getting the modelling right is non-negotiable.
Multi-Asset & Extensibility
Not just fiat. Not just today.
Multi-Asset Ledger Support
Fiat (AUD, USD, EUR, GBP), stored value, loyalty points, and crypto-ready rails. Each asset type with its own rules and precision.
Why: Loyalty points, gift balances, multi-currency wallets all need proper ledger treatment. Single-currency platforms limit product roadmaps.
Alias-Based Addressing
PayID-style aliases (email, phone, custom identifiers) mapped to accounts. Multiple aliases per account. Inbound routing without exposing internal IDs.
Why: Every modern payment experience depends on alias addressing. Native support means no custom routing layer.
Built by Operators. Not by Outsourcers.
Kobble Core was built to power Yondr Money and Shouta in production. Every capability exists because it was needed, not guessed. That's the difference between operator-built infrastructure — where real products and real customers drive every design decision — and outsourcer-built systems that try to anticipate requirements from a distance. When you build on Core, you're building on a ledger that has already been proven at scale in the Australian market.
One API for accounts and transactions
Create accounts with sub-ledgers and post transactions with rule evaluation. Idempotent, well-documented, and built for production.
# Create a wallet (ledger account for a holder)POST /v1/wallets{ "holder_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "asset_class": "CURRENCY", "asset": "AUD", "partner_product": "KOBBLE_AUD_1"}# Create an inter-wallet transaction (move value between wallets)POST /v1/transactionsHeader: Idempotency-Key: <uuid>{ "from": "wallet-uuid-debit", "to": "wallet-uuid-credit", "amount": 100.50, "reference": "Payment #1234", "payment_type": "INTER_WALLET", "metadata": {}}