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

Creating a PayPal-like payment application traditionally requires extensive backend development, complex security implementations, and separate codebases for web, iOS, and Android platforms. For entrepreneurs and startups looking to enter the fintech space, this means months of development time, significant technical expertise, and substantial investment before even reaching your first user. The combination of user authentication, wallet management, real-time transactions, and cross-platform compatibility makes digital payment apps one of the most challenging projects to tackle.

That's where Adalo comes in. Adalo is a no-code app builder for database-driven web apps and native iOS and Android apps—one version across all three platforms. AI-assisted building and streamlined publishing enable launch to the Apple App Store and Google Play in days rather than months. This means you can focus on designing a seamless payment experience and validating your fintech concept while the platform handles the technical complexity of multi-platform deployment.

Why Adalo Works for Building a Payment App

Adalo is a no-code app builder for database-driven web apps and native iOS and Android apps—one version across all three platforms, published to the Apple App Store and Google Play. This makes it particularly well-suited for creating a PayPal-style payment app, where you need secure user databases, real-time transaction tracking, and the ability to reach users wherever they are—whether on their phone or desktop.

For a digital wallet app, native app store distribution is essential. Users expect payment apps to live on their home screens for quick access, and they need push notifications for transaction alerts, payment confirmations, and security updates. With Adalo, you can build once and deploy everywhere, giving your users a seamless experience across all their devices while you focus on creating a trustworthy financial tool.

Building a payment app like PayPal might sound impossible without coding experience, but with Adalo’s platform, you can create a functional digital wallet application in weeks rather than months. This tutorial walks you through building an app with user authentication, wallet management, money transfers, and transaction history. You can even publish the same app to the web, native iOS, and native Android with Adalo, all without writing a line of code or rebuilding anything.

Compliance note: Fintech apps have significant regulatory obligations (e.g., money transmission, KYC/AML, sanctions). Plan early with a fintech attorney and, where appropriate, banking partners.

Prerequisites and Initial Setup

Step 1: Create Your Adalo Account and Project

1. Visit Adalo.com and sign up for a free account
2. Click Create New App on your dashboard
3. Choose Mobile App (recommended for payment apps)
4. Name your project (e.g., “PaymentPro” or “QuickPay”)
5. Select Start from Scratch

Step 2: Configure Your App Settings

1. Open App Settings (gear icon)
2. Set your brand theme:

• Primary: trustworthy tone (blue/green)
• Secondary: complementary accent
• Background: white/light gray

3. Choose a professional, readable font
4. Enable responsive design for different devices
5. Save

Step 3: Set Up Payment Processing Requirements

• Stripe Account: Sign up at Stripe.com
• Test API Keys: Use Stripe test mode while developing
• Security: Review PCI DSS basics for card handling
• Legal: Confirm licensing and program setup with counsel

Using Stripe (or Stripe Connect) can reduce scope, but does not automatically cover licensing/compliance. Validate requirements for your model/jurisdictions.

Building the Database Structure

Step 4: Enhance the Users Collection

1. Click the Database icon
2. Open Users
3. Add properties:

• Phone Number (Text)
• Profile Image (Image)
• Account Status (Text: “Active”, “Suspended”, “Pending Verification”)
• KYC Status (Text: “Not Started”, “In Progress”, “Verified”, “Rejected”)
• Date of Birth (Date)
• Address (Text)
• Wallet Balance (Number)
• Currency (Text, e.g., “USD”)
• Account Created (Date & Time – Automatic)
• Last Login (Date & Time)
• Identity Verification Token (Text — reference from KYC provider)

Don’t store SSN digits or ID images in Adalo. Use a compliant identity provider and store only tokens/statuses.

External Collections overview

Step 5: Create the Transactions Collection

1. + Add Collection → Transactions
2. Properties:

• Transaction ID (Text – Auto-Generated)
• Type (Text: “Send”, “Receive”, “Deposit”, “Withdrawal”, “Request”)
• Amount (Number)
• Currency (Text)
• Status (Text: “Pending”, “Processing”, “Completed”, “Failed”, “Cancelled”, “Declined”)
• Description (Text)
• Recipient Email (Text)
• Sender Email (Text)
• Fee Amount (Number)
• Created Date (Date & Time – Automatic)
• Completed Date (Date & Time)
• Error Message (Text)

Step 6: Create the Payment Methods Collection

1. + Add Collection → Payment Methods
2. Properties:

• Method Type (Text: “Credit Card”, “Debit Card”, “Bank Account”)
• Card Last 4 (Text)
• Card Brand (Text: “Visa”, “Mastercard”, “Amex”, “Discover”)
• Expiration Month (Number)
• Expiration Year (Number)
• Is Default (True/False)
• Stripe Payment Method ID (Text)
• Bank Name (Text)
• Account Last 4 (Text)
• Created Date (Date & Time – Automatic)

PCI scope: Use Stripe Elements/Payment Element so card data never touches your servers. Stripe pricing varies by region/method; in the U.S., online card rates commonly start around 2.9% + $0.30 per successful charge.

Step 7: Create the Wallet Transfers Collection

1. + Add Collection → Wallet Transfers
2. Properties:

• Transfer ID (Text – Auto-Generated)
• Amount (Number)
• Status (Text: “Pending”, “Completed”, “Failed”)
• Transfer Type (Text: “User to User”, “Add Funds”, “Withdraw”)
• Created Date (Date & Time – Automatic)
• Notes (Multiline Text)

Step 8: Create the Notifications Collection

1. + Add Collection → Notifications
2. Properties:

• Title (Text)
• Message (Multiline Text)
• Type (Text: “Payment Received”, “Payment Sent”, “Deposit”, “Security Alert”)
• Is Read (True/False)
• Created Date (Date & Time – Automatic)
• Action URL (Text)

Step 9: Set Up Database Relationships

• Transactions → Users: Sender (Many-to-One), Recipient (Many-to-One)
• Transactions → Payment Methods: Many-to-One
• Payment Methods → Users: Owner (Many-to-One)
• Wallet Transfers → Users: From User (Many-to-One), To User (Many-to-One)
• Wallet Transfers → Transactions: One-to-One
• Notifications → Users: Recipient (Many-to-One)
• Notifications → Transactions: Many-to-One (optional)

Installing Required Components

Step 10: Install Stripe

1. Open the Adalo Marketplace
2. Install Stripe
3. Configure test keys (pk_test_…, sk_test_…)
4. Plan note: Stripe components are available on paid plans

Step 11: Install QR Code (Optional)

• Install QR Code Generator (Marketplace) for shareable payment requests

Step 12: Install Charts (Optional)

• Add chart components for transaction graphs, spending analytics, and balance trends

Creating User Authentication and KYC

Step 13: Welcome Screen

• Rename to Welcome
• Logo, headline, subheading
• Buttons: Sign Up, Login
• Footer: Terms and Privacy links

Step 14: Sign Up

• Screen Sign Up
• Form (Users): Full Name, Email, Phone, Password, Confirm Password
• Checkbox for Terms/Privacy
• Create Account:
  
  • Create User (Wallet Balance = 0; Account Status = “Pending Verification”)
  • Send email verification (Zapier/automation)
  • Go to Email Verification

Step 15: Email Verification

• Text: code sent to {email}
• Input: 6-digit code
• Verify:
  
  • Update Account Status → “Active”
  • Navigate to KYC Information
• Resend Code

Step 16: KYC Information

Use Stripe Identity/Persona (hosted flow). Store tokens/statuses only.

• Collect DOB and address fields (update Logged In User)
• Start Verification → create provider session via backend; save Identity Verification Token; set KYC Status = “In Progress”; open hosted flow
• I’ve Completed Verification → check result, update KYC Status → next screen

Step 17: Login

• Screen Login with Email + Password
• Forgot Password? → Password Reset
• (Optional) 2FA: integrate Twilio Verify/Firebase Auth and gate sensitive actions with codes

Building the Home Dashboard

Step 18: Home

• Header: profile image, “Hi, {First Name}”, settings
• Wallet card: Wallet Balance, currency, Add Funds, Withdraw
• Quick actions: Send Money, Request Money, Add Funds
• Recent Activity: Transactions where Sender = or Recipient = Logged In User; newest first; limit ~5

Step 19: KYC Alert Banner

• If KYC Status ≠ “Verified” → “Complete verification to unlock full features” → Verify Now

Building the Send/Request Flows

Step 20: Send Money

• Recipient search (email) or QR scan (if installed)
• Amount input; show available balance; optional note
• Fee copy: “Fee: ${calc} • Total: ${amount + fee}”

Step 21: Confirm Payment

• Summary: recipient, amount, fee, total
• Security: password/PIN; optional 2FA code
• Confirm & Send:
  
  • Check balance
  • Create Transaction (Status “Processing”)
  • Deduct sender; credit recipient (or move from pending to available)
  • Update Transaction → “Completed”
  • Notify recipient
  • Go to Payment Success

Step 22: Payment Success

• Success state (amount, recipient, Transaction ID, date/time)
• View Receipt, Send Another, Return Home

Step 23: Request Money

• Email, amount, reason
• Send Request → Create Transaction (Type “Request”, Status “Pending”); notify target

Step 24: Payment Requests

• List pending requests where Recipient = Logged In User
• Show requester, amount, reason
• Pay (to confirmation) or Decline (Status → “Declined”)

Integrating Stripe for Real Payments

Step 25: Add Funds

• Presets + custom amount
• Choose saved card or add new
• Stripe Payment component:
  
  • Amount = selection
  • Customer Email = user email
  • Save card option enabled
• On success:
  
  • Increase Wallet Balance
  • Create Transaction (Type “Deposit”, Status “Completed”)
  • Notify user

Step 26: Payment Methods

Add Payment Method

• Use Stripe Payment Element/card UI (component/webview)
• Save Stripe Payment Method ID, brand, last4; mark first card default

Manage Payment Methods

• List: brand icon, last4, expiry, default badge
• Actions: Set Default, Remove, Add New

ACH: Native Stripe component focuses on cards. For ACH, add Custom Actions with Stripe APIs and (typically).

Building Withdrawals

Step 27: Withdraw Funds

• Amount input (min, e.g., $10), available balance
• Bank account selector (link bank via Plaid/Stripe)
• Copy: “Payout timing varies by country and bank; in the U.S., standard Stripe payouts are often 2–3 business days.” 
• Request Withdrawal:
  
  • Create Transaction (Type “Withdrawal”, Status “Processing”)
  • Deduct balance
  • Notify user
  • Flip to Completed/Failed via backend webhook

Server-side only: External payouts generally require Stripe Connect and must be initiated on your server.

Step 28: Bank Accounts

• List: bank name, last4, type, verification status
• Link New Bank: Plaid/Stripe flow; support micro-deposits if needed

Implementing Transaction History

Step 29: Transaction History

• Filters: date range, type (All/Sent/Received/Deposits/Withdrawals/Requests), status
• List: icon, counterparty, amount (+/–), date/time, status
• Tap → Transaction Details

Step 30: Transaction Details

• Show: ID, type/status, amount/currency, fee, date/time, counterparty, method, notes
• Actions: Download Receipt (CSV/PDF via integration), Report Issue, Repeat Transaction

Step 31: Search & Export

• Search by recipient/sender email or Transaction ID
• Export CSV (automation/integration)

Building Notifications

Step 32: Notifications Center

• List notifications for Logged In User; newest first
• Each: icon, title, message, time ago, unread indicator
• Tap: mark read; deep link via Action URL when present

Step 33: Push Notifications

1. Enable push in Adalo settings
2. Request permission on first login
3. Triggers:

• Money received: “You received ${Amount} from {Sender}”
• Money sent: “Payment of ${Amount} sent to {Recipient}”
• Deposit complete: “Your deposit of ${Amount} is available”
• Low balance, security alerts

Publishing & push overview

Adding Security Features

Step 34: PIN/Password

• Security Settings: PIN lock for app open/sensitive actions
• Store only a salted hash of PIN (hash on your server)
• Biometrics: Not native for app-level auth; consider third-party components/services or rely on device-level protections

Step 35: Transaction Limits

• Show defaults (e.g., Daily $2,500; Per-Tx $1,000; Monthly $10,000)
• Request Increase → requires full KYC (route to Support/KYC)

Step 36: Activity Log

• List logins (date/time, device, location if available, IP)
• Report Unauthorized Access; Log Out All Devices

Settings and Profile Management

Step 37: Settings Hub

• Account: Profile Info, Change Password, Email Preferences
• Payments: Payment Methods, Bank Accounts, Transaction Limits
• Security: PIN, 2FA (third-party), Activity Log
• Support: Help/FAQ, Contact Support, Terms & Privacy

Step 38: Edit Profile

• Update photo, full name, phone, DOB (lock after verification), address
• Validate and save

Step 39: Change Password

• Current, New (≥ 8), Confirm; strength meter
• On success: send confirmation email

Testing Your Payment App

Step 40: Test Users

• 5–10 users (mix of verified/unverified), varied balances, different payment methods
• Stripe test cards:
  
  • Success: 4242 4242 4242 4242
  • Declined: 4000 0000 0000 0002
  • 3DS required: 4000 0027 6000 3184

Step 41: Core Flows

• Send Money: balances/notifications/records
• Add Funds: success/failure handling, history
• Requests: create/pay/decline, notifications
• Withdrawals: creation, balance deduction, webhook status updates

Step 42: Security & Edge Cases

• Insufficient funds, invalid emails, expired cards, duplicates
• Validation for negatives/over-limit/special chars/missing fields
• Performance: 100+ transactions, image sizes, error/empty states

Step 43: Preview & Debug

• Web + mobile preview
• Verify visibility rules, fee/balance math, deep links
• Check loading and retry patterns; add clear error toasts

Working Within Platform Limitations

Step 44: Constraints & Workarounds

Real-Time: No sockets; use timers (5–10s) to refresh lists. Consider Xano.
Complexity: Multi-currency and fraud scoring need external APIs/services; use Make/Zapier for orchestration.
Compliance: KYC/AML via external providers; maintain audit trails and retention as required.

Step 45: Refresh Patterns

• Pull-to-refresh on Home/Transactions
• Countdown auto-refresh (~10s) on high-traffic screens
• Show “Last updated” timestamps

Publishing Your Payment App

Step 46: Prepare for Production

• Switch to live keys (Stripe/others)
• Add Terms of Service, Privacy Policy, and (web) Cookie Policy; link in onboarding/footer
• Hardening: no client secrets, TLS-only endpoints, tokens for PII

Step 47: Custom Domain (Web)

• Connect domain in Publishing and enable SSL
• Configure DNS per Adalo docs
• Paid plan required

Step 48: Publish to Stores

iOS

• Join Apple Developer Program ($99/year)
• Publish → iOS; upload assets/metadata; submit via App Store Connect
• Review times vary (many complete within 24–48 hours, but can take longer)

Android

Create Google Play Developer ($25 one-time)

Publish → Android; upload AAB/assets; complete rating & data safety

Review times vary; can take several days or longer

Web

• Publish → Web; use Adalo subdomain or your custom domain

Publishing overview

Step 49: Plan Updates

• Enable manual publishing to control releases
• Cadence: monthly features, weekly fixes as needed, immediate security patches
• Communicate via in-app messages and release notes

Post-Launch Optimization

Step 50: Monitor Key Metrics

Acquisition (signups, onboarding completion), engagement (DAU/MAU, sends/user, add-funds conversion), retention (D1/D7/D30), financial (gross volume, deposit/withdraw rates, failure rates), technical (errors, latency, webhook success).

Step 51: Gather Feedback

In-app forms, store reviews, analytics/session replays, user interviews.

Step 52: Iterate

Performance (queries, pagination, images), UX (limits UI, request-money flow, QR pay), risk (step-up rules), clarity (fees & timing copy), onboarding (KYC guidance, empty states).

Why Choose Adalo for Payment Apps

• Security & Reliability: Monitor uptime/incidents at status.adalo.com.
• Stripe Integration: Native Stripe for cards; add ACH via Custom Actions/Stripe APIs/Plaid.
• Flexible Database: Visual relationships for users ↔ transactions ↔ payment methods.
• Cross-Platform: Publish to iOS, Android, and web. For mobile usage context, see DataReportal Digital 2026.
• Scale Options: Use Xano for heavier logic and custom APIs.
• Cost-Effective: U.S. developer comp commonly exceeds $100K (BLS). Adalo offers tiered plans—see pricing. Stripe fees vary—see pricing.

Additional Resources

• Adalo Database: https://help.adalo.com/database
• External Collections: https://help.adalo.com/integrations/external-collections-with-apis
• Custom Actions: https://help.adalo.com/integrations/custom-actions
• Optimize performance: https://help.adalo.com/performance/optimize-app-performance
• Adalo Marketplace: https://www.adalo.com/marketplace
• Stripe Pricing: https://stripe.com/pricing
• Stripe Testing: https://stripe.com/docs/testing
• Stripe ACH: https://stripe.com/docs/ach
• Stripe Payouts: https://stripe.com/docs/payouts
• Stripe Connect Payouts: https://stripe.com/connect/payouts
• Apple App Review: https://developer.apple.com/app-store/review/
• Google Play (Dev Help): https://support.google.com/googleplay/android-developer/answer/9859152
• Adalo Status: https://status.adalo.com/
• Gartner LC/NC stat: https://www.gartner.com/en/newsroom/press-releases/2021-02-15-gartner-forecasts-worldwide-low-code-development-technologies-market-to-grow-23-percent-in-2021

Note: Treat this as a prototype. For production money movement and custody, integrate regulated partners, keep sensitive data off the client/app DB (use tokens), initiate payouts server-side, and run full security/compliance reviews before launch.

FAQ