Step-by-Step Guide: Building a Coinbase Clone with Adalo

This guide walks you through creating a cryptocurrency exchange-style app using Adalo’s no-code platform. While bespoke crypto exchanges can take months and substantial budgets, a no-code approach lets you prototype core flows—registration, KYC capture, portfolio view, buy/sell orders (off-chain accounting), and payments—in weeks.

‍

Important: This guide implements a custodial/off-chain balance model in Adalo. On-chain deposits/withdrawals and blockchain signing/broadcasting require external services via External collections or Custom actions.

Setting Up Your Adalo Account for Crypto App Development

Step 1: Create Your Adalo Account

1. Visit Adalo.com and sign up.
2. Verify your email.
3. Create New App → choose Mobile App.
4. Name your project (e.g., “CryptoExchange”).
5. Start from Scratch (no crypto-specific template).

Step 2: Choose Your Plan

Review Adalo pricing for current plan features and publishing eligibility.

‍

• Free: prototype/testing.
• Starter / Professional / Team / Business: check the live page for publishing, API features, limits, and add-ons. For API-heavy crypto apps, use Professional or above (required for Custom actions).

Step 3: Configure Your App Theme

Pick a trustworthy palette (navy/green), set typography, spacing, and corner radii, then continue into the builder.

Building the Database Structure

Step 4: Create the Users Collection

Database → Users → add properties:

‍

• Full Name (Text), Phone Number (Text), Profile Image (Image)
• KYC Status (Text): “Pending”, “Verified”, “Rejected”
• Document Type/Number (Text), Date of Birth (Date), Country (Text)
• Two Factor Enabled (True/False)
• Account Balance USD (Number), Total Trades (Number)
• Created Date (Date & Time – automatic)

Step 5: Create the Wallets Collection (Off-Chain)

+ Add Collection → “Wallets”

‍

• Coin ID (slug) (Text), Symbol (Text), Balance (Number)
• Address (display) (Text) if using external custody
• QR Code (Image), Created Date (Date & Time)

Step 6: Create the Transactions Collection

+ Add Collection → “Transactions”

‍

• Transaction ID (internal) (Text)
• Type (Text): “Buy”, “Sell”, “Deposit”, “Withdraw”
• Cryptocurrency (Text), Amount (Number)
• Price Per Unit (Number), Total USD (Number), Fee (Number)
• Status (Text): “Pending”, “Completed”, “Failed”, “Cancelled”
• Payment Method (Text)
• Blockchain TX Hash (Text – only if using on-chain flows via external API)
• Created Date (Date & Time), Completed Date (Date & Time)

Step 7: Create the Market Prices Collection

+ Add Collection → “Market Prices”

‍

• Coin ID (slug), Symbol, Cryptocurrency (name)
• Current Price USD, 24h Change %, Market Cap, Volume 24h
• Last Updated (Date & Time)

Step 8: Set Up Database Relationships

• Users ↔ Wallets: One User → Many Wallets
• Users ↔ Transactions: One User → Many Transactions
• Wallets ↔ Transactions: optional Many-to-One (for wallet-specific logs)

‍

Database guide

Designing the User Authentication System

Step 9: Build the Welcome Screen

Logo + tagline, and buttons to Create Account and Login.

Step 10: Create the Sign Up Screen

Form (Users): Email, Password, Full Name, Phone, Country (+ Terms checkbox).
Submit actions: Create User → navigate to KYC or dashboard.

‍

Email verification: Implement via Custom actions or automation (e.g., SendGrid) using Adalo’s tutorial: verification email. There is no always-on “automatic” verification—configure it in your flow.

Step 11: Build the Login Screen

Email/Password → Login.
If Two Factor Enabled is true → route to 2FA Verification.

Step 12: Implement Two-Factor Authentication (TOTP)

Create 2FA Setup and 2FA Verification screens.

‍

• Generate a TOTP secret server-side (via external API) and display it as a QR.
• Users add it to Authy/Google Authenticator; verify 6-digit codes on login via Custom actions.
  
  

See TOTP overview (industry standard). OWASP Mobile

Step 13: Create KYC Verification Flow

KYC Verification screen (Users update): document type/number, DOB, front/back images, selfie → set KYC Status = Pending and notify admin.

‍

Compliance: In most jurisdictions, exchanges must implement KYC/AML and obtain required registrations/licensing. Requirements vary—consult regulators and counsel. FinCEN • FATF guidance

Creating the Cryptocurrency Dashboard

Step 14: Build the Main Dashboard

• Total Portfolio Value = Σ(wallet balance × current price).
• Market Overview list (Market Prices): symbol, name, price, 24h change, etc.
• Nav: My Wallets, Trade, Transactions.

Step 15: Connect to Price APIs

Use External collections or API component to connect to CoinGecko.
Endpoint: /coins/markets (vs_currency=usd, order=market_cap_desc).
Mapping (correct):

‍

• id → Coin ID (slug) (e.g., “bitcoin”)
• symbol → Symbol (e.g., “btc”)
• name → Cryptocurrency (name)
• current_price → Current Price USD
• price_change_percentage_24h → 24h Change %
• market_cap → Market Cap
  Refresh via a timer pattern or screen revisit.

Step 16: Create Portfolio Analytics

Portfolio screen: list user wallets with amount held, current value, % of portfolio, and 24h P/L.
Add charts via Component marketplace.

Building Buy and Sell Functionality

Step 17: Create the Trading Screen

Tabs for Buy and Sell.

‍

• Buy: choose crypto, show price, amount, cost, fee, final total, payment method.
• Sell: choose crypto (wallets with balance > 0), show proceeds and fee.

Step 18: Implement Order Processing

Validations: balance checks, KYC Status = Verified.
On submit: create Transaction (Pending) → Order Confirmation → on confirm:

‍

• For off-chain trades: update balances and mark Completed with an internal Transaction ID.
• For on-chain withdrawals/deposits: use your custodian/blockchain API via Custom actions; store the returned blockchain hash.

Step 19: Integrate Payment Processing (Fiat → App Balance)

Install Stripe or Marketplace Payments (for multi-party payouts). Configure keys and create a charge to fund USD balance; on success, complete the transaction flow.

‍

Fees: In the U.S., online card pricing is typically 2.9% + $0.30 per successful charge; fees vary by country and payment method. Stripe pricing

Designing Wallet Features

Step 20: Build the Wallets Screen

List user wallets: icon, balance, USD value, and + to add a wallet record.

Step 21: Wallet Details Screen

Show coin name, balance, value, optional display address/QR (if using custody).
Actions: Deposit, Withdraw, Transaction History.

Step 22: Deposit Flow (If Using External Custody)

Display “Send to this address” details returned by your custody API.
Monitor incoming TX via External collections; on confirmations, update balance and notify the user.

Step 23: Withdrawal Flow (If Using External Custody)

Form: recipient address, amount, network fee, priority.
Validate balance, run 2FA, call custody API via Custom actions, then update status as confirmations arrive.

Implementing Security Features

Step 24: Security Settings

Add toggles for 2FA, change password, and notification preferences.

Step 25: Rate Limiting (App Logic)

Track failed attempts in Users; lock after threshold and notify. (Business logic in Adalo database + actions.)

Step 26: Data Protection Notes

Adalo provides authentication and HTTPS; consult current materials for data-protection details and handle secrets carefully. See Mobile app security (OWASP) and Adalo’s security best-practice content.

Do not store private keys in Adalo; use dedicated key management/custody.

Step 27: Activity Logs

Create an Activity Log collection (action, IP/device, time, status).
Log sensitive actions and show a recent history screen.

Testing Your Crypto Exchange App

Step 28: Create Test Data

Seed test users (KYC states, 2FA on/off), wallets, and transactions.
Use Stripe test cards for payment tests.

Step 29: Test Core Workflows

• Registration & KYC: Sign up → submit KYC → verify notifications.
• Trading: Buy/Sell flows; balance updates.
• Wallet ops: (if using custody) deposit/withdraw on testnets.
• Security: 2FA, lockout thresholds, password resets, activity logs.

Step 30: Performance Optimization

Compress images, limit list sizes, and cache price data. See Optimize performance and consider External collections for large datasets.

Publishing Your Crypto Exchange App

Step 31: Prepare for Launch

Switch to production keys (Stripe, price data, custody), set push notifications, and add legal pages (Privacy, Terms, Risk, Fee schedule). Set up support flows.

Step 32: App Store Submission

• iOS: Join Apple Developer Program ($99/year) and follow Adalo’s iOS guide.
• Android: Pay $25 one-time and follow Adalo’s Android guide.

Step 33: Web App Deployment

Configure a custom domain via web aapp publishing; set SSL and DNS, then test responsiveness.

Platform Limitations and Workarounds

Real-Time & Background Limits

‍

• Adalo doesn’t provide native background tasks or true live sockets; “live” price changes require screen revisit or a timer-based refresh.
• For real-time price streams, order books, or background polling, integrate an external service via Custom Actions or External collections.

‍

On-Chain Operations

‍

• Adalo cannot sign/broadcast blockchain transactions natively. Use a custody/node provider via Custom actions; store the returned blockchain hash for on-chain deposits/withdrawals.
• Never store private keys in Adalo—use dedicated custody or key management.

‍

Scalability

‍

• Very large datasets (prices, ticks, ledgers) should live in an external store. Use External collections and follow Optimize performance (limit list sizes, progressive loading, image optimization).

‍

Compliance & Risk

‍

• KYC/AML, licensing/registration, sanctions screening, and travel-rule obligations vary by jurisdiction. Treat this as a custodial/off-chain prototype and connect regulated vendors as needed. See FinCEN and FATF guidance.

‍

Workaround Strategies

‍

• Cache ticker summaries in-app; keep full ledgers in an external DB.
• Use timers/screen revisit for “near-real-time” UI; use sockets/webhooks in external services.
• Add an Admin/Compliance screen for manual reviews and KYC status changes.
• Split roles into multi-app (Customer / Admin / Ops) when teams scale.

Cost Breakdown and Resources

Adalo Subscription

‍

• Verify current plan features/limits on the Adalo Pricing page (publishing, API features, team seats).

‍

Payments & Fiat On-Ramps

‍

• U.S. Stripe reference: typically 2.9% + $0.30 per successful card charge; varies by country/method. 

‍

Crypto Data & Node/Custody (examples)

‍

• Market data APIs (e.g., CoinGecko/CoinMarketCap): free tiers; higher usage is metered.
• Node/custody/KYC vendors: usage-based pricing—confirm volumes and regions.

‍

Other Services

‍

• Notifications: built-in Push via Adalo; optional SMS/email via external providers.
• App stores: Apple Developer $99/year; Google Play $25 one-time.
• Ongoing maintenance: many teams budget ~15–25% annually (scope-dependent).

Additional Resources

• Adalo Database — collections, properties, relationships
• External Collections — connect external APIs
• Custom Actions — call third-party endpoints
• Optimize Performance — lists, images, data strategy
• Stripe Payments · Marketplace Payments
• CoinGecko Markets API — endpoint & fields
• Coinbase availability context: Investor FAQ · Prohibited regions

‍

Coinbase operates in 100+ countries; your app’s availability depends on your licensing/compliance and vendor coverage by region.

Note: This Coinbase-style clone implements custodial/off-chain balances, market price views, buy/sell flows (off-chain accounting), fiat funding via Stripe, and KYC intake using Adalo’s features plus API integrations. For production-grade exchange capabilities—live order books, on-chain custody, automated compliance checks, and background processing—connect regulated vendors through Custom Actions/External Collections, keep lists lean, and performance-test on real devices before publishing.