The Architecture Behind Unit

A technical primer on how Unit works, for teams building financial products.

Elroie Roash
CTO
Read
12 minutes
Last Updated
November 4, 2026

A bank-core architecture is one where the platform that runs your financial products is installed at the bank as the system of record, rather than layered on top of the bank’s legacy core. Unit works this way. Your accounts, balances, and payments live on Unit’s native ledger, which runs alongside the bank’s existing core and connects directly to the Federal Reserve and payment networks.

TLDR:

  • Unit is installed at the bank as the core system of record for your program, with its own routing number and account range, so there is no middleware layer in the payment path.
  • Payments go directly to Federal Reserve systems and The Clearing House, which exposes network-level data such as IMADs, ACH trace numbers, return codes, and settlement dates.
  • The bank and your company share one ledger, reconciled daily, and your bank relationship stays direct and yours.
  • Unit supports multiple bank partners on one API and Dashboard, with configurable control over which parts of your program Unit runs and which you take on.

Why the infrastructure between your software and the bank matters

Whether financial products are part of your software or your entire product, you need to decide what infrastructure sits between your application and the banking system.

This matters more than most teams realize during evaluation. The architecture you build on determines what data you can access, how payments behave, what you can debug when something breaks, and whether you'll need to rebuild systems as you scale.

It also determines what happens when your requirements change (and they will):

  • Can you add a second bank partner without a separate integration? 
  • Can you support a new payment rail like RTP without waiting for your provider's roadmap? 
  • Can you control operational details like ACH clearing windows or check deposit workflows, or are those locked inside a system you can't reach? 
  • Is your relationship with the bank actually yours, or mediated through your provider?

Much of today's financial infrastructure runs on top of legacy bank infrastructure that was never designed to be programmable. That rigidity is invisible during evaluation. It shows up six or twelve months later, when the product needs to evolve and the infrastructure can't.

This guide covers five architectural choices that define how Unit works: running as the bank's core, our native ledger, direct network connectivity, multi-bank partnerships, and configurable control boundaries: what each one does, why we built it that way, and how to evaluate whether it fits what you're building.

1. Unit is the core system of record for your program

Every bank runs on a core: the system of record that holds its balances and transactions and connects it to the payment networks. Most banks license theirs from Jack Henry, Fiserv, or FIS, and those systems were built for batch files and human operators, not APIs.

Many providers sit on top of that legacy core. They keep a second ledger of their own and reconcile it back to the bank's books. They inherit every limit of the core underneath, and add a second set of books that can drift from the bank's.

Unit is installed at the bank as the system of record for your program, running alongside the bank's existing core rather than on top of it. Your accounts, balances, and payments live on Unit and never touch the bank's legacy core technology.

  • Recognized by the Fed as a bank service provider. Partner banks designate Unit to the Federal Reserve as their service provider, the same recognition the Fed gives core providers like Jack Henry, Fiserv, and FIS.
  • Its own routing number and account range. The bank assigns Unit's ledger a routing number and a range of account numbers, so accounts on Unit are addressable on the payment networks directly.
  • One ledger, shared with the bank. The bank and your company work from the same ledger, reconciled to the cent daily. The bank sees every account and transaction in real time through the Dashboard.

Without a legacy core in the path, you get capabilities like same-day ACH with multiple cutoffs a day, your company's name on outgoing ACH and wire transfers, and same-day limit changes.

2. Every account and payment rail runs on a single, native ledger

When you create an account through the API, that account exists in Unit's native ledger: the core described above, and the operational system of record for all account and transaction activity. Balances update in real time, transactions are recorded as they happen, and reconciliation is continuous, not batched overnight.

Every state transition is recorded on the ledger with timestamps tied to actual network events. You can see exactly where a payment is relative to cutoff windows, settlement, and returns. The same ledger data is accessible through a Dashboard, so your operations team and bank partners can view account activity, transaction history, and payment status without requiring engineering support or separate reporting tools.

The ledger supports deposit accounts, wallet accounts, and credit accounts as distinct, first-class account types, each with its own data model and behavior, all maintained on the same ledger. All accounts are shown in a single dashboard.

‍‍

3. Unit connects directly to the Fed and payment networks

Unit is a registered service provider with the Federal Reserve. Payments flow from our infrastructure directly to Federal Reserve systems, on behalf of our partner banks.

Under the hood, we operate dedicated infrastructure in secure Equinix data centers where we run the Federal Reserve's required systems for Fedwire, FedACH, and checks. We've built and maintain our own services that speak the Fed's protocols directly, and we're regularly examined to stay certified.

When you originate a payment through the API, it is submitted directly to the Federal Reserve network on behalf of partner banks. There is no intermediary processing layer in the middle.

This architecture is what allows the infrastructure to expose true network-level detail and status. IMADs (Input Message Accountability Data), precise settlement timestamps, raw return codes, and real-time updates aren't approximations or delayed relays - they come from the Federal Reserve messages we receive and process ourselves.

This matters for three reasons:

  1. Processing windows are explicit. ACH doesn’t run continuously. It moves in defined Federal Reserve windows throughout the day. Because the infrastructure submits payments directly to the network, we align submission to those windows. You know exactly when a payment will be processed, not just when your API call returned successfully.‍
  2. Network acknowledgments are observable. When the Fed acknowledges receipt of a payment, that event is captured and exposed. You're not inferring status from the absence of errors, it’s based on actual network responses.
  3. ‍Settlement timing is deterministic. You know when funds will settle because the system tracks the real network lifecycle end to end. Settlement timing reflects what’s happening at the Federal Reserve, not an approximation layered on top of a bank’s legacy system.

Because we build direct to the metal, we can expose the data the networks actually produce. For wires, that includes the IMAD and OMAD identifiers assigned by Fedwire, network timestamps for each lifecycle event, and raw status codes when something fails. For ACH, it includes trace numbers, return reason codes (R01, R02, etc.) as received from the network, and actual settlement dates, not estimated ones.

Other payment networks work the same way: Unit connects directly to The Clearing House (TCH) for RTP and issues cards directly on the card networks, with no processing layer in between.

4. Direct bank relationships, across multiple banks, on one API

Your relationship with the bank is yours, not mediated through Unit. You choose your bank partner. You negotiate terms directly. Your teams work together on compliance, operations, and program design. We provide the infrastructure that makes the partnership work; we don't sit between you and the bank. Deposit accounts on Unit are held at partner banks and FDIC-insurance eligible under the bank's charter.

This is an architectural choice, not just a commercial decision. The API and Dashboard work consistently regardless of which bank partner is behind a given account. That means:

  • You can start with one bank and add others as your program scales or your needs change
  • Different products or customer segments can run on different bank partners through the same integration
  • If you need to move accounts from one bank to another, the migration tooling handles it without disrupting end users

This matters because regulatory shifts, management changes, consent orders, strategic pivots… these happen, and when they do, single-bank dependency becomes an existential risk. Multi-bank support isn't a feature you'll need someday. It's insurance you want from day one.

5. Take control of any part of your program, now or over time

There isn't a one-size-fits-all approach when it comes to offering financial services. We've built modular Roles & Responsibilities settings to let you take control of specific parts of your program, immediately or over time. You can use Unit's capabilities for KYC/KYB, card processing, fraud prevention, and compliance monitoring. Or you can bring your own stack where you have specialized requirements or existing vendor relationships. These boundaries are configurable and can change over time, in coordination with your bank partner.

This means you're not locked into a single operating model. Teams often start with Unit handling most operational complexity, with oversight from partner banks, then selectively take on more control as their program matures and their internal capabilities grow. The platform supports both approaches (and the transition between them), without requiring migration or reintegration. Dive deeper into each part of your program with our guide to program management.

This runs in production, at scale

  • Scale: Processing 11M+ API calls per day and $100+ billion in transactions annually.
  • Uptime: Maintains 99.999% uptime, reflecting consistently high reliability.
  • Secure & compliant: SOC 2 Type 2 and PCI DSS.
  • Developer experience: A single API, a single dashboard, and comprehensive documentation. Your engineering team, your operations team, and your bank partner all work from the same system. 

Next Steps

If you're evaluating an financial infrastructure platform:

Explore the API documentation. The API reference shows exactly what data is available for each resource type. Look at the payment objects as the fields exposed there reflect the network-level visibility we've described.

Sign up for sandbox access. The best way to understand the infrastructure is to use it. Create accounts, submit payments, and see what data comes back.

Talk to the team. If you have specific architectural questions about payment flows or bank partner options, please reach out.

‍

FAQs

Is Unit middleware between my application and the bank?

‍No. BaaS middleware sits on top of a bank’s legacy core and typically keeps its own ledger. Unit is installed at the bank as the system of record for your program, running alongside the bank’s existing core. Your accounts, balances, and payments live on Unit’s native ledger and don’t pass through the legacy core.

What is the difference between a middleware layer and a core system of record?

‍A core system of record holds a bank’s balances and transactions and connects it to the payment networks. Middleware relies on a third party’s core and adds a layer on top, which can create a second set of books that drifts from the bank’s. Unit acts as the core for your program, so Unit and the bank work from one shared ledger, reconciled daily.

Does Unit send payments through an intermediary processor?

‍No. Unit is recognized by the Federal Reserve as a bank service provider and submits payments directly to Fedwire and FedACH on behalf of partner banks. Unit connects directly to The Clearing House for RTP and issues cards directly on the card networks. Because there is no processing layer in between, you receive network-level data such as IMADs, trace numbers, return reason codes, and settlement dates.

Who owns the bank relationship when I build on Unit?

‍You do. You choose your bank partner, negotiate terms directly, and work with the bank on compliance, operations, and program design. Unit provides the infrastructure and doesn’t sit between you and the bank. Deposit accounts are held at partner banks and may be eligible for FDIC insurance.¹

Can I use more than one bank without rebuilding my integration?

‍Yes. The Unit API and Dashboard work the same way regardless of which partner bank sits behind an account. You can start with one bank, add others as your program grows, run different products on different banks through the same integration, and move accounts between banks with Unit’s migration tooling. Availability depends on your program and bank partner requirements.

Do I have to use Unit for every part of my program?

‍No. Unit’s Roles & Responsibilities settings let you use Unit for KYC/KYB, card processing, fraud prevention, and compliance monitoring, or bring your own vendors where you have specialized requirements. These boundaries can change over time in coordination with your bank partner, without migration or re-integration.

‍

* Unit is a financial technology company and is not a bank. Banking products and services are provided by Unit’s partner bank(s), Members FDIC.

Originally Published
February 18, 2026