How to build an app like Revolut: Neobank architecture, features, and timeline

Most founders who want to build a neobank think they're building a banking app. They're not. They're building a ledger, a compliance machine, a card program, and a regulatory relationship - then putting a clean UI on top.

Revolut took 4 years and $900M in funding to become what it is today. But Revolut's 2015 MVP - a prepaid card with no FX markup - cost far less to build than most people assume. The reason is that they didn't build a bank. They built a product on top of a bank.

That's the mental model you need before you write a single line of code.

What Revolut actually is

Before talking architecture, it helps to list what Revolut actually contains. Most people see one app. It's really eight products:

1. Multi-currency bank account - hold and manage balances in 36 currencies
2. Debit card program - virtual and physical Visa/Mastercard with real-time spending controls
3. FX exchange - real mid-market rates up to a monthly limit, then a small markup
4. Crypto trading - buy/sell 100+ cryptocurrencies within the app
5. Stock investing - fractional shares and commission-free trading on US and EU markets
6. Insurance - travel, gadget, and medical insurance sold within the app
7. Business banking - multi-user accounts, bulk payments, accounting integrations
8. Expense management - receipts, categories, team spend limits

Revolut's 2015 launch had exactly one of these: the multi-currency card. They spent 5 years adding the others.

Your MVP should contain one, maybe two. The architecture needs to support adding more later without a full rewrite.

The banking infrastructure question

Here's the question most founders avoid: can you actually hold customer money?

The answer depends on your license. A full banking license (the kind JPMorgan or Barclays has) lets you hold deposits, earn interest on those deposits, and lend from your own balance sheet. Getting one takes 2-5 years and $20M+ in capital requirements, depending on the country.

Almost nobody starts there. Instead, you use a banking-as-a-service (BaaS) provider - a licensed bank that issues accounts and cards on your behalf while you build the product experience.

Popular options in 2026:

• Stripe Treasury - US accounts, FDIC-insured deposits, fast API integration
• Column - actual bank (not just a BaaS wrapper), popular with startups wanting more control
• Synapse - multi-bank routing, broader product options
• Railsbank - UK and EU, good for cross-border
• Swan - EU-focused, strong compliance tooling for European markets

The tradeoff: BaaS providers are faster to launch but cut into your margin and create dependency. Revolut eventually obtained its own banking license in Lithuania (2018) to reduce that dependency and gain EU passporting rights.

For your MVP, use a BaaS provider. Worry about licensing when you've hit $10M in annualized transaction volume.

Core architecture: Four layers

A neobank has four distinct technical layers. Each is a real engineering challenge.

Layer 1: The ledger

This is the most important piece and the one most teams underinvest in.

A multi-currency ledger tracks every user's balance in every currency, plus every transaction, fee, FX conversion, and reversal. It's a double-entry accounting system - every debit has a corresponding credit, and the books must balance at all times.

The key properties a ledger needs:

• Idempotency - every transaction has a unique ID; retrying a failed payment never creates a duplicate charge
• Consistency - no partial writes; either the full transaction commits or it rolls back
• Auditability - every state change is logged with a timestamp and actor ID; you can replay the full history of any account

Most teams reach for a standard relational database (PostgreSQL is fine) and add an event-sourcing layer on top. Every balance change is an event - you derive the current balance by replaying events, not by storing a single mutable value. This makes audits trivial and reversals clean.

Layer 2: The payment rails

Money moves in and out via payment rails - the network infrastructure that connects banks. Different countries use different rails:

• SEPA Instant - euro transfers within the EU (up to 10 seconds)
• ACH - US dollar transfers (1-3 business days)
• Faster Payments - UK domestic transfers (seconds)
• SWIFT - international wires (1-5 days)
• PIX - Brazil (instant)
• UPI - India (instant)

Your BaaS provider handles most of this. But you still need to build the integration layer that routes payments to the right rail, handles failures, and reconciles settlements.

Layer 3: The compliance stack

This is where most neobank projects blow timelines and budgets.

KYC (Know Your Customer) - verify that each user is who they say they are. In practice, this means:

• Document upload (passport, driver's license)
• Liveness check (selfie + motion detection to prevent photo spoofing)
• Identity database check against global watchlists
• Address verification

Most teams use a third-party KYC provider - Onfido, Jumio, or Persona - rather than building this from scratch. These APIs handle the document parsing and liveness detection. You handle the decision logic (approve, reject, flag for manual review).

AML (Anti-Money Laundering) - monitor transactions for suspicious patterns. Regulators expect you to flag:

• Large cash deposits or withdrawals above reporting thresholds
• Structuring (multiple transactions just below the threshold)
• High-risk country transactions
• Velocity anomalies (unusual spike in transaction frequency or amount)

AML monitoring runs continuously in the background. You need a rules engine, an alert queue for manual review, and a suspicious activity report (SAR) filing workflow. Budget 20-30% of your backend development cost for this layer.

GDPR / data privacy - financial data is sensitive personal data. You need a lawful basis for processing, data retention policies, and a mechanism for users to export or delete their data.

Layer 4: The card program

Cards are what make a neobank feel like a bank to users. They're also a separate technical integration.

Card issuing - you work with a card issuer processor (Marqeta is the dominant choice; Lithic and Stripe Issuing are alternatives). They give you an API to create cards, fund them from your ledger, and authorize/decline transactions in real time.

Card controls - freeze/unfreeze, spending limits by merchant category, single-use virtual cards, location-based controls. These are the features that differentiate neobank UX from a legacy bank.

The card integration is typically 8-12 weeks, including the testing cycles that processors require before you can go live.

The FX engine: Revolut's real moat

Revolut's core value proposition in 2015 was simple: no FX markup. Most banks charge 2-4% on currency conversions. Revolut passed on the mid-market rate.

Building this requires:

1. Live FX rate feeds - you pull real-time rates from providers like Refinitiv, Bloomberg, or XE
2. A hedging relationship - when a user converts $1,000 to euros, you need a counterparty who takes the other side. Revolut works with institutional FX counterparties. At MVP scale, you can work with an FX aggregator API (Currency Cloud, owned by Visa, is popular)
3. Rate locking - the rate shown to the user must be locked for a window (typically 30-60 seconds) while they confirm. After that window, the rate refreshes
4. FX markup logic - free plan users get the mid-market rate up to a monthly limit. Premium users get it unlimited. Your billing system needs to track FX volume per user per month

At MVP scale, the FX engine is a 12-16 week build. At scale, it's an ongoing operations function - you're essentially running a small treasury desk.

Features by tier

Tier 1: MVP (24-36 weeks, $120K-$250K)

• User onboarding and KYC (via Onfido or similar)
• Multi-currency account (2-3 currencies to start)
• Virtual card issuance
• Incoming bank transfers (ACH or SEPA)
• Outgoing transfers to bank accounts
• In-app FX exchange (simple markup model, no mid-market rates yet)
• Transaction history and notifications
• Basic security (biometric login, 2FA, device management)

Tier 2: Growth platform (12-18 more weeks, $100K-$200K additional)

• Real mid-market FX rates with tier-based limits
• Physical card with card controls
• Savings vaults (sub-accounts earning interest)
• Scheduled payments and recurring transfers
• Spending analytics by category
• Referral program

Tier 3: Full platform (24-36 more months, $500K+)

• Crypto buying/selling
• Stock investing (requires additional licensing - a brokerage license)
• Business accounts
• Expense management
• Lending products
• Insurance marketplace
• Joint accounts

The timeline most teams don't expect

The longest lead-time item isn't development - it's banking partner onboarding.

When you engage a BaaS provider, they need to:

1. Conduct their own KYC on your business
2. Review your compliance policies and procedures
3. Run a technical integration review
4. Complete regulatory filings, in some cases

This process takes 6-12 weeks regardless of how fast your engineers move. Start it on day one.

Similarly, Marqeta or any card issuer processor will run a technical certification process before you can issue live cards. Budget 4-6 weeks for that.

A realistic end-to-end timeline for an MVP launch:

Where teams consistently go wrong

Building compliance last. Compliance isn't a feature you add before launch. It's a design constraint that shapes every data model, every flow, and every third-party integration. Teams that bolt it on at the end spend 3-6 months rebuilding.

Underestimating the ledger. A Google Sheets budget tracker is not a ledger. A database with a balance column is not a ledger. A real financial ledger is a precision instrument. One bug - one case where a debit doesn't match its credit - and you've got an audit finding and potentially customer harm. Invest in this early.

Skipping the fraud layer. Neobanks are attractive targets for fraud because the accounts are easy to open. You need velocity rules (don't allow 10 accounts to be created from the same device), device fingerprinting, and anomaly detection before you process a single live transaction.

Picking the wrong BaaS provider. Not all BaaS providers offer the same product capabilities, pricing, or reliability. Synapse's 2024 bankruptcy left 10 million end users without access to funds for weeks. Vet your banking partner the same way you'd vet a co-founder.

Tech stack

• Mobile: React Native or Flutter (cross-platform, one codebase)
• Backend: Node.js or Go for API services; event sourcing with Kafka or AWS Kinesis
• Ledger: PostgreSQL with strict ACID transactions
• KYC: Onfido, Jumio, or Persona
• Card issuing: Marqeta or Stripe Issuing
• BaaS: Stripe Treasury, Column, or Synapse (US); Swan or Railsbank (EU)
• FX rates: Currency Cloud or Refinitiv
• AML monitoring: ComplyAdvantage or Sardine
• Infrastructure: AWS or GCP with multi-region for uptime

The build vs. license decision

For your first 2 years, you don't need a banking license. BaaS plus good compliance operations is enough to build, launch, and find product-market fit.

When you should consider pursuing a license:

• You're processing $500M+ in annual transaction volume and BaaS margins hurt
• You want to hold deposits and earn interest (requires a banking license in most jurisdictions)
• You're expanding internationally and need regulatory passporting (EU banking license opens 27 countries)
• Your BaaS provider's instability has become a risk to your business

Most successful neobanks - Chime, Monzo, N26, Revolut - operated under BaaS or e-money licenses for years before pursuing full banking licenses. The license isn't what makes the product. The product makes the product.

If you're building a fintech app, our fintech development team has built payment systems, FX platforms, and compliance stacks across dozens of products. See our breakdown of AI applications in fintech and how AI agents are changing financial services to understand where AI fits in the stack.