Building a payment app like PayPal might sound impossible without coding experience, but with Adalo’s no-code 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—all without writing native code.
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
- Visit Adalo.com and sign up for a free account
- Click Create New App on your dashboard
- Choose Mobile App (recommended for payment apps)
- Name your project (e.g., “PaymentPro” or “QuickPay”)
- Select Start from Scratch
Step 2: Configure Your App Settings
- Open App Settings (gear icon)
- Set your brand theme:
- Primary: trustworthy tone (blue/green)
- Secondary: complementary accent
- Background: white/light gray
- Choose a professional, readable font
- Enable responsive design for different devices
- 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
- Click the Database icon
- Open Users
- 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.
Step 5: Create the Transactions Collection
- + Add Collection → Transactions
- 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
- + Add Collection → Payment Methods
- 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
- + Add Collection → Wallet Transfers
- 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
- + Add Collection → Notifications
- 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
- Open the Adalo Marketplace
- Install Stripe
- Configure test keys (pk_test_…, sk_test_…)
- 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
- Enable push in Adalo settings
- Request permission on first login
- 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
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
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 2023.
- 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.
Start Building With An App Template
Build your app fast with one of our pre-made app templates
