Most founding teams that set out to launch a fintech make the same expensive decision in their first quarter: they build payment rails from scratch. Six months later the pattern is predictable. The first real customer arrives, the stack is not production-ready, compliance is a patch bolted on at the end, and the technical debt is already too large to pay down cleanly.
Launching a fintech that handles crypto and fiat payments does not require reinventing the infrastructure. It requires choosing the right foundations, and getting the parts that are hard to change (custody, compliance, licensing) correct on the first pass. This guide walks through what “production-ready” actually means, the foundations that must exist on day one, a reference architecture, and a realistic 90-day plan.
The most expensive mistake: building before validating the infrastructure
Engineering teams love to build. That instinct is exactly what sinks early fintechs. Payment rails look like a solved problem from the outside (move a number from A to B), but the parts that break in production are the ones you cannot see in a demo: reconciliation, settlement timing, failed and reversed transactions, sanctions hits, and the audit trail a regulator will ask for.
The trap is that building your own rails feels like progress while it quietly caps your ceiling. A fintech that grows on badly designed in-house infrastructure hits a wall fast: it cannot scale into a new market without rewriting the core, it cannot add a new asset without weeks of integration, and it cannot survive an audit without intense manual work. Choosing specialised B2B infrastructure is not outsourcing your product. It frees your engineers to build the thing that actually differentiates you.
What “production-ready” actually means for crypto and fiat
Before you write a line of code, be honest about the bar. A crypto-and-fiat payment platform is production-ready when it can:
- Move value between crypto and fiat in one continuous flow, not two disconnected systems stitched together per transaction.
- Reconcile every movement automatically, with a ledger that balances continuously and an immutable audit trail.
- Screen every transfer for identity, sanctions and counterparty risk without human bottlenecks.
- Handle the unhappy paths: retries, reversals, network congestion, and partial failures.
- Produce the reports a regulator or partner bank will ask for, on demand, without a data-migration project.
If your MVP cannot do these things, it is a prototype, not a platform. The good news is that none of them require you to build from zero.
The day-one foundations
Five things belong in your architecture from the first commit. Skipping any of them is the decision you will pay for later.
Multi-currency accounts and balances
Your users think in their local currency. Your suppliers, investors or counterparties may settle in USDC, EUR or USD. A platform that treats each currency as a separate island turns every cross-border movement into an engineering problem.
Start with named accounts per user and a unified balance that can hold multiple currencies, backed by real bank details where the market needs them (US ACH, European SEPA, UK Faster Payments, and local rails such as CLABE, PIX or PSE in Latin America). Deposits should be able to auto-convert to a stablecoin so that value is instantly usable across the rest of the system.
Unified crypto and fiat rails
This is the core. The market rewards flexibility, and flexibility comes from treating crypto and fiat as one rail rather than two:
- On-ramp: convert local currency to stablecoin or crypto with no friction for the end user.
- Off-ramp: settle back to local fiat from digital assets, with predictable settlement windows.
- Cross-border: move value between jurisdictions in stablecoin, with FX handled inline, instead of waiting on slow correspondent banking.
When these three flows live behind one API, a payment from a peso wallet to a dollar bank account stops being a bespoke project and becomes a single call.
Card issuing that spends from the balance
A card is how most users actually touch their money. Modern card issuing lets you launch virtual and physical Visa or Mastercard programs where the card spends directly from the user’s balance, crypto or fiat, with no pre-funding pools to manage. The important design choice is that the wallet connects to the card network so spending happens against the real-time balance, with granular limits, freeze controls and 3-D Secure built in.
Custody model: why non-custodial changes your regulatory profile
Here is where many teams make a quiet but costly error: they treat custody as a pure security problem. It is also a regulatory and operational one.
In a custodial model you hold your users’ funds and keys. That places you inside safeguarding and money-transmission rules, forces segregation and audit obligations onto your balance sheet, and makes you the single richest target on the network.
In a non-custodial model users keep control of their own funds and every movement needs their approval. You run the program without ever holding customer money. This does not make compliance disappear, but it materially reduces the surface you have to safeguard and it changes the licensing conversation. For many products, non-custodial is the difference between needing a heavyweight licence yourself and being able to operate as an agent of a licensed partner.
Whichever model you choose, the non-negotiables are the same: fund segregation that is auditable in real time, complete traceability of every movement, and signing policies configurable to your product’s risk profile.
Embedded compliance, not bolted on afterwards
Compliance added after launch is the most expensive compliance there is. It means redesigning flows, migrating data and, in the worst case, pausing operations. Building with compliance from day one means:
- KYC/KYB verification inside the onboarding flow, not as an extra step.
- AML transaction monitoring with rules configurable per jurisdiction.
- Sanctions and PEP screening on onboarding and on every transfer.
- Travel-rule data attached to qualifying transfers automatically, without slowing them down.
- Regulatory reporting generated for the relevant authority in each market.
The cleanest architectures ship these as part of the base stack, not as optional add-ons you integrate later.
Licensing: MSB, money transmitter, and leaning on partners
Licensing is where founders freeze, usually because they assume they need everything themselves. You often do not.
| Question | Typical answer |
|---|
| Do you hold or transmit customer funds? | If yes, you likely need MSB registration and, in most US states, a money transmitter licence. |
| Are you non-custodial and an agent of a licensed institution? | You can often operate on your partners’ licences for the regulated parts. |
| Serving the EU? | Consider an EMI or payment-institution licence, and VASP/MiCA registration for crypto. |
| Serving specific US states or LATAM markets? | Licensing usually follows where your customers are, not where you are incorporated. |
The practical move is to map your licensing perimeter early: who controls the funds, which markets you serve, and which regulated parts can ride on partner licences. Get that map from counsel before you scale, not after.
A reference architecture for launch
For a crypto-and-fiat MVP in production in under 90 days, the minimum viable architecture is smaller than most teams expect:
- A unified payments API (crypto and fiat) with webhooks for every transaction event.
- A wallet and custody layer with segregated, non-custodial balances per user.
- A compliance engine with KYC embedded in onboarding and transaction monitoring on every movement.
- An operations dashboard so your team can manage settlements, alerts and reports without touching the database.
A white-label option lets you launch this whole stack under your own brand, which shortens time to market without giving up control of the user experience. Your engineers integrate against one API surface instead of stitching together a liquidity provider, a custodian, a KYC vendor and a card processor, each with its own contract, failure modes and reconciliation quirks.
A realistic 90-day launch plan
Days 1 to 15, scope and perimeter. Define the exact flows you need (accounts, on/off-ramp, cards, cross-border) and the markets you will serve. Map your compliance and licensing perimeter with counsel. Get a sandbox key and validate the API against one real flow end to end.
Days 16 to 45, integrate the core. Wire up accounts, the unified payments API and the compliance engine. Build onboarding with KYC in the flow. Implement webhooks and idempotency so your ledger is auditable and no event is processed twice.
Days 46 to 75, harden and add rails. Add card issuing and cross-border payouts. Test the unhappy paths: reversals, sanctions hits, network delays. Stand up the operations dashboard and your monitoring and reporting.
Days 76 to 90, controlled launch. Run a closed pilot with real users and real money at low limits. Confirm reconciliation, settlement timing and the audit trail hold under real conditions, then raise limits and open the doors.
The variable in this timeline is never the technology. It is your product scope and the compliance perimeter your chosen markets create.
Expensive mistakes to avoid
- Building rails to feel productive. Custom infrastructure feels like progress and quietly caps your ceiling. Build what differentiates you; integrate the rest.
- Treating custody as only a security problem. It is also regulatory and operational. Decide custodial versus non-custodial deliberately, because it drives your licensing.
- Adding compliance last. It is the single most expensive way to do it. Embed KYC/AML and the travel rule from the first flow.
- Assuming you need every licence yourself. Map the perimeter; much of the regulated surface can ride on licensed partners.
- Ignoring the unhappy paths. Reversals, failures and sanctions hits are where prototypes break and platforms prove themselves.
Build versus buy: a simple decision framework
Build the parts that are your product and your differentiation: the experience, the vertical logic, the data and relationships your users come for. Buy (or integrate) the parts that are undifferentiated, hard to get right, and expensive to maintain: the rails, custody, compliance plumbing and card processing.
The test is simple. If a component would look almost identical at any competent fintech, it is infrastructure, and infrastructure is not where you win. Your engineering time is the scarcest asset you have; spend it on the 20% that only you can build.
Deep dives on each foundation above:
Where Tokelia fits
Tokelia is the infrastructure for programmable money: virtual accounts, unified crypto-and-fiat rails, card issuing, cross-border payments and stablecoins, behind one API, with a non-custodial architecture and compliance built into the base stack rather than sold as add-ons. Money services are provided by Tokelia LLC, a company registered as a Money Services Business with FinCEN, with regulated banking delivered by licensed institutions, so you can launch under your own brand while the heavy, hard-to-change parts are already solved.
If you are scoping a launch, the fastest way to pressure-test this against your own use case is to walk a real flow with our team.