Step-by-Step Guide: Building an Instacart Clone with Adalo

This comprehensive tutorial will walk you through building a fully functional grocery delivery marketplace using Adalo's no-code platform. You'll learn how to create a three-sided marketplace connecting customers, shoppers, and retailers with order management, payment processing, real-time tracking, and rating systems—all without writing a single line of code.

What Is an Instacart Clone and Why Build One with a No-Code App Builder

An Instacart clone is a multi-sided marketplace that connects grocery retailers, independent shoppers, and customers seeking convenient delivery. The platform enables customers to browse products from local stores, place orders, and receive delivery within hours—while independent shoppers fulfill orders and earn per-delivery fees plus tips.

The business model operates without owning physical inventory or delivery fleets. Successful platforms monetize through multiple revenue streams: customer delivery fees, service fees, retailer commissions, subscription memberships, and CPG brand advertising for sponsored product placements.

Core Features of On-Demand Delivery Apps

Essential marketplace functionality includes:

• Product catalog management: Category-based browsing, search, filters, and inventory synchronization
• Multi-sided user authentication: Separate interfaces for customers, shoppers, and retailers with role-based permissions
• Order fulfillment workflow: Request creation, shopper assignment, status tracking (pending, accepted, in-progress, completed)
• Real-time order tracking: GPS-enabled shopper location updates and delivery ETA calculations
• Payment processing: Split payment architecture routing funds to retailers while collecting platform commissions
• Rating and review system: Two-way ratings between customers and shoppers to maintain service quality

Why No-Code Platforms Work for Delivery Marketplaces

Traditional marketplace development requires $70,000-$100,000 in capital and 6-12 months of engineering work. No-code platforms like Adalo eliminate these barriers by providing pre-built components for listings, payments, user management, and location services.

Customer-facing applications built on no-code platforms also generate 58% higher revenue than equivalent traditionally-coded apps, proving that rapid iteration and user feedback loops drive superior business outcomes.

Planning Your Instacart Clone: User Roles and App Architecture

Before building, map out the three distinct user types and their workflows. Clear role definition prevents database confusion and ensures logical screen flows.

Mapping Customer-Side Screens

Customer journey includes:

1. Welcome/Login: User authentication with email or social sign-on
2. Store Selection: Browse participating retailers by category or location
3. Product Catalog: Search, filter, and browse products with images, prices, and descriptions
4. Shopping Cart: Real-time total calculation with taxes and fees
5. Checkout: Address confirmation, delivery time selection, payment method
6. Order Tracking: Live shopper location, order status updates, estimated delivery time
7. Order Completion: Receipt, rating prompts, reorder options
8. Order History: Past orders with reorder functionality

Designing Shopper-Side Workflows

Shopper interface focuses on efficiency:

1. Shopper Dashboard: Availability toggle, today's earnings summary
2. Available Orders: List of nearby orders with store location, item count, payout
3. Order Acceptance: Accept/decline with 60-second response window
4. Shopping Mode: Item checklist, substitution options, customer messaging
5. Navigation: GPS routing to customer address with external maps integration
6. Delivery Confirmation: Photo upload, signature capture, completion actions
7. Earnings Tracker: Daily/weekly totals, payout schedule

Admin Panel Requirements

Administrative functions include:

• User management (approve shoppers, handle disputes)
• Store/product catalog oversight
• Transaction monitoring and reconciliation
• Analytics dashboard (order volume, revenue, ratings)
• Support ticket management

Draw a simple flowchart showing how data connects: Customers create Orders → Orders assigned to Shoppers → Orders belong to Stores → Payments link to Orders. This visual reference guides database setup in the next section.

Setting Up Your Adalo Project: Choosing the Best No-Code App Builder for Delivery Apps

Adalo's no-code builder supports unlimited screens and actions with a built-in relational database across iOS, Android, and web platforms—making it suitable for complex delivery marketplace builds starting at the Free tier for testing.

Selecting Your Adalo Plan for an On-Demand App

Plan comparison for delivery apps:

• Free: Unlimited test apps, 200-500 records per app, 1 editor, web publishing on Adalo subdomain—perfect for prototyping your marketplace logic
• Starter ($36-45/month): 1 published app, custom domains, unlimited database records, custom branding—suitable for local market launch
• Professional ($52-65/month): 2 published apps, 5 collaborators, 25GB storage, geolocation support, custom integrations—required for GPS tracking features
• Team ($160-200/month): 5 published apps, 10 editors, priority support, Xano integration for advanced data scaling
• Business ($200-250/month): 10 published apps, unlimited editors, special add-on pricing for growing operations

Start with the Free plan to validate marketplace mechanics, then upgrade to Professional for geolocation and payment features. Check Adalo pricing for current rates.

Configuring Multi-Platform Publishing Settings

Setup steps:

1. Navigate to Adalo.com and create your account
2. Click "Create New App" from the dashboard
3. Select "Mobile App" as your primary platform (enables iOS and Android publishing)
4. Enable "Responsive Design" toggle to support web browsers alongside mobile
5. Name your project (e.g., "FreshCart" or "LocalGrocer")
6. Choose "Start from Scratch" (no grocery delivery templates available)
7. Set brand colors:
   
   • Primary color: Fresh green (#2ECC71) for CTAs and headers
   • Secondary color: Neutral gray (#34495E) for text and borders
8. Select a clean sans-serif font like Inter or Roboto for readability

Click "Continue" to enter the visual editor. Your workspace now includes the database panel (left sidebar), screen canvas (center), and component library (right sidebar).

Building Your Database: Product Catalogs, Orders, and User Collections

Adalo's built-in relational database with prebuilt property types and custom formulas allows you to model complex delivery marketplace data without external database tools.

Creating the Products Collection with Inventory Fields

1. Click the Database icon in the left sidebar

2. Click "+ Add Collection" and name it "Products"

3. Add these properties:

• Product Name (Text)
• Description (Text - Multiline)
• Product Image (Image)
• Price (Number - Currency format)
• Category (Text) - Options: "Produce", "Dairy", "Meat", "Pantry", "Frozen", "Beverages", "Snacks"
• Unit Type (Text) - Options: "each", "lb", "oz", "gallon"
• SKU (Text)
• In Stock (True/False)
• Stock Quantity (Number)
• Store (Relationship to Stores collection - created next)

4. Create the "Stores" collection with properties:

• Store Name (Text)
• Store Logo (Image)
• Address (Text)
• Location (Location)
• Phone (Text)
• Store Type (Text) - Options: "Grocery", "Pharmacy", "Specialty"
• Commission Rate (Number) - Default 15-20%

5. Link Products to Stores:

• In Products collection, add relationship "Store" → Many Products belong to One Store

Designing the Orders Collection with Status Tracking

The Orders collection is the central hub connecting customers, shoppers, products, and payments.

1. Create "Orders" collection with properties:

• Order Number (Text - Auto-Generated)
• Status (Text) - Options: "Pending", "Accepted", "Shopping", "Delivering", "Completed", "Cancelled"
• Subtotal (Number)
• Delivery Fee (Number) - Default $5-7
• Service Fee (Number) - Default $2-4
• Tax Amount (Number)
• Total Amount (Number)
• Delivery Address (Text)
• Delivery Location (Location)
• Delivery Instructions (Text - Multiline)
• Requested Delivery Time (Date & Time)
• Actual Delivery Time (Date & Time)
• Created Date (Date & Time - Automatic)

2. Create "Order Items" collection (line items for cart):

• Quantity (Number)
• Unit Price (Number)
• Line Total (Number - calculated via custom formula)
• Substitution Allowed (True/False)
• Special Instructions (Text)

Linking Shoppers to Orders via Relationships

Establish database relationships to connect all collections:

1. In Orders collection, add relationships:

• Customer → Many Orders belong to One User (as Customer)
• Shopper → Many Orders belong to One User (as Shopper)
• Store → Many Orders belong to One Store

2. In Order Items collection, add relationships:

• Order → Many Order Items belong to One Order
• Product → Many Order Items reference One Product

3. Enhance the Users collection (already exists) with properties:

• Phone Number (Text)
• Profile Image (Image)
• User Type (Text) - Options: "Customer", "Shopper", "Admin"
• Shopper Status (Text) - Options: "Available", "Busy", "Offline"
• Current Location (Location)
• Average Rating (Number)
• Total Ratings Count (Number)
• Vehicle Type (Text) - Options: "Car", "Bike", "Scooter"
• Background Check Status (Text) - Options: "Pending", "Approved", "Rejected"

4. Create "Ratings" collection:

• Rating Value (Number - 1 to 5)
• Comment (Text - Multiline)
• Created Date (Date & Time - Automatic)
• Rater → Relationship to Users (person giving rating)
• Rated → Relationship to Users (person being rated)
• Order → Relationship to Orders

Your database now mirrors the multi-sided marketplace architecture that powers successful delivery platforms. Learn more about Adalo's database capabilities.

Designing the Customer-Facing Screens with a Free App Builder

Adalo's truly drag-and-drop builder with responsive design and custom branding (Starter+ plans) enables you to create fully-custom customer interfaces without flexbox or code.

Creating the Home Screen with Product Categories

1. Add a new screen named "Home"
2. Add a Top Bar component:
   
   • Left: User profile icon
   • Center: Location selector showing delivery address
   • Right: Cart icon with item count badge
3. Add a Text component: "What would you like today?"
4. Add a Horizontal Card List:
   
   • Data source: Stores collection
   • Filter: Where In Stock = True
   • Card contents: Store Logo (Image), Store Name (Text)
   • Click action: Navigate to "Store Detail" screen, passing the Store
5. Add a Custom List for product categories:
   
   • Static items: Produce, Dairy, Meat, Pantry, Frozen, Beverages, Snacks
   • Display as horizontal scrollable icons with category names
   • Click action: Navigate to "Category Products" screen with category filter
6. Add a Search Bar component:
   
   • Placeholder: "Search for products..."
   • Action: Navigate to "Search Results" with query parameter

Building the Product Detail and Add-to-Cart Flow

1. Create "Store Detail" screen:

• Receives: Store object from previous screen
• Add Image for Store Logo
• Add Text for Store Name and Address
• Add Custom List of Products:
  
  • Filter: Where Product → Store = Current Store AND In Stock = True
  • Sort by: Category, then Product Name
  • Display: Product Image, Name, Price, Unit Type
  • Click action: Navigate to "Product Detail"

2. Create "Product Detail" screen:

• Receives: Product object
• Add Image for Product Image
• Add Text for Product Name
• Add Text for Price (formatted as currency)
• Add Text for Description
• Add Number Input for quantity (default = 1)
• Add Toggle for "Allow substitutions?"
• Add Text Input for special instructions
• Add Button "Add to Cart":
  
  • Action: Create Order Item (if cart order exists) OR Create new Order + Order Item
  • Set: Product, Quantity, Unit Price, Line Total (Quantity × Unit Price)
  • Navigate back with success message

3. Set up cart logic using conditional actions:

• Check if Logged In User has an Order where Status = "Pending" (this is the active cart)
• If yes: Add item to existing Order
• If no: Create new Order with Status = "Pending", Customer = Logged In User

Designing the Checkout and Payment Screen

1. Create "Cart" screen:

• Add Custom List showing Order Items:
  
  • Filter: Where Order → Status = "Pending" AND Order → Customer = Logged In User
  • Display: Product Image, Name, Quantity, Line Total
  • Include "Remove" button: Delete Order Item
• Add Text for Subtotal: Sum of all Order Items → Line Total
• Add Text for Delivery Fee: $5 (can add logic for distance-based pricing)
• Add Text for Service Fee: $2
• Add Text for Tax: Subtotal × 0.08 (8% sales tax)
• Add Text for Total: Sum of all fees
• Add Button "Proceed to Checkout" → Navigate to "Checkout" screen

2. Create "Checkout" screen:

• Add Form component updating current Order:
  
  • Location Input for Delivery Address (default to user's saved address)
  • Text Input for Delivery Instructions
  • Date & Time Picker for Requested Delivery Time
• Add order summary showing Total Amount
• Add Button "Place Order" with custom action:
  
  • Update Order: Set Status = "Pending" (awaiting shopper)
  • Navigate to "Finding Shopper" screen

The customer interface is now complete. Use the Adalo font library to customize typography for brand consistency.

Building Shopper Workflows: Order Assignment and Real-Time Updates

Adalo's Professional plan includes geolocation support and custom actions that enable real-time order tracking and status-based workflows essential for on-demand delivery.

Displaying Available Orders to Shoppers

1. Create "Shopper Home" screen:

• Add Toggle component:
  
  • Label: "Available for Orders"
  • Action on change: Update Logged In User → Shopper Status
  • When ON: Set to "Available"
  • When OFF: Set to "Offline"
• Add Text showing today's earnings:
  
  • Formula: Sum of Orders where Shopper = Logged In User AND Status = "Completed" AND Created Date = Today
• Add Custom List of available orders:
  
  • Filter: Status = "Pending" AND Store → Location within 10 miles of Logged In User → Current Location
  • Sort by: Created Date (newest first)
  • Display: Store Name, Item Count, Estimated Payout, Distance
  • Click action: Navigate to "Order Detail"

2. Create "Order Detail" screen for shoppers:

• Receives: Order object
• Add Map component showing Store Location
• Add Text for Store Name and Address
• Add Custom List of Order Items with Product Names and Quantities
• Add Text for Total Items count
• Add Text for Payout amount (you define the shopper fee structure)
• Add two Buttons:
  
  • "Accept Order": Update Order (Shopper = Logged In User, Status = "Accepted"), Navigate to "Shopping Mode"
  • "Decline": Navigate back

Implementing Order Status Transitions

Create a sequential workflow screen set:

1. "Shopping Mode" screen:

• Display Order Items as checklist
• Add Checkbox for each item (mark as found)
• Add Button per item: "Request Substitution" → Send message to customer
• Add Button "Shopping Complete" → Update Status to "Shopping", Navigate to "Ready for Delivery"

2. "Ready for Delivery" screen:

• Show customer delivery address on map
• Display delivery instructions
• Add Button "Start Delivery" → Update Status to "Delivering", Navigate to "Delivery Navigation"

3. "Delivery Navigation" screen:

• Add Map showing route from current location to delivery address
• Add Button "Open in Maps App":
  
  • Link to: https://maps.google.com/?q=[Delivery Latitude],[Delivery Longitude]
• Add Button "I've Arrived" → Show delivery confirmation options
• Add Button "Complete Delivery":
  
  • Update Status to "Completed"
  • Set Actual Delivery Time to Now
  • Navigate to "Delivery Complete"

Adding Geolocation for Delivery Tracking

Professional plan feature enables real-time tracking:

1. On "Delivery Navigation" screen, add Update Location action:

• Trigger: Every 10 seconds (use Countdown Timer component set to repeat)
• Action: Update Logged In User → Current Location to device's current position

2. On customer's "Order Tracking" screen:

• Add Map component
• Add markers for:
  
  • Delivery Address (Order → Delivery Location)
  • Shopper Location (Order → Shopper → Current Location)
• Map updates automatically as shopper location changes

3. Add status-based conditional visibility:

• Show "Finding Shopper" message when Status = "Pending"
• Show "Shopper Accepted" with shopper details when Status = "Accepted"
• Show live map when Status = "Shopping" or "Delivering"
• Show completion confirmation when Status = "Completed"

Note: Geolocation requires a Professional plan ($52-65/month annual pricing). Without it, use address-based tracking only. Check Adalo's geolocation features for implementation details.

Integrating Payment Processing with Stripe Components

Adalo integrates with Stripe via marketplace components, allowing you to process payments securely within delivery apps without custom backend code.

Adding the Stripe Payment Component to Checkout

1. Visit the Adalo Marketplace and search for "Stripe"
2. Click "Install" on the Stripe component
3. Create a Stripe account at stripe.com if you don't have one
4. Get your API keys from Stripe Dashboard → Developers → API Keys:
   
   • Publishable Key (starts with pk_test_ for testing)
   • Secret Key (starts with sk_test_ for testing)
5. In Adalo, go to Settings → Integrations → Stripe and paste your keys

Now implement payment on the Checkout screen:

1. On "Checkout" screen, add Stripe Payment component:

• Amount: Current Order → Total Amount
• Currency: USD
• Description: "Grocery Order #" + Order Number
• Save card for future use: Yes
• On successful payment action:
  
  • Create Payment record (track transaction)
  • Update Order → Payment Status to "Paid"
  • Navigate to "Finding Shopper" screen

2. Create "Payment Methods" screen for saved cards:

• Add List of saved payment methods from Stripe
• Show last 4 digits, card brand, expiration
• Add "Set as Default" option
• Add "Remove Card" button

Configuring Stripe Webhooks for Order Confirmation

For production apps, set up webhooks to handle payment confirmations:

1. In Stripe Dashboard, go to Developers → Webhooks
2. Click "Add endpoint"
3. Enter your webhook URL (Adalo provides this in Stripe integration settings)
4. Select events to listen for:
   
   • payment_intent.succeeded
   • payment_intent.payment_failed
5. Save the webhook endpoint and copy the signing secret
6. Add the signing secret to Adalo's Stripe integration settings

When a payment succeeds, Stripe notifies your app automatically, triggering any configured actions like sending confirmation emails or updating inventory.

For marketplace split payments where retailers receive funds directly while you collect commissions, explore Stripe Connect integration—available through premium Adalo marketplace components.

Adding Custom Logic: Conditional Actions and Order Automation

Adalo's built-in AND/OR logic and custom formulas enable you to automate complex delivery workflows and calculations without external automation tools.

Setting Up Conditional Visibility for Order States

Use visibility conditions to show different content based on order status:

1. On "Order Tracking" screen, add multiple Text components:

• Text 1: "Finding a shopper..." → Visible when: Order → Status = "Pending"
• Text 2: "Shopper accepted your order" → Visible when: Order → Status = "Accepted"
• Text 3: "Shopper is shopping" → Visible when: Order → Status = "Shopping"
• Text 4: "On the way to you!" → Visible when: Order → Status = "Delivering"
• Text 5: "Order delivered!" → Visible when: Order → Status = "Completed"

2. Add conditional buttons:

• Button "Cancel Order" → Visible when: Status = "Pending" OR Status = "Accepted"
• Action: Update Order → Status to "Cancelled", Navigate back

3. Show shopper information only when assigned:

• Image and Text for shopper name/photo → Visible when: Order → Shopper is not empty

Automating Shopper Notifications with Actions

Set up automatic notifications when orders are placed:

1. On the "Place Order" button action (Checkout screen), add custom action:

• Send Notification to all users where:
  
  • User Type = "Shopper"
  • Shopper Status = "Available"
  • Current Location within 10 miles of Order → Store → Location
• Notification title: "New Order Available"
• Notification body: "Order at [Store Name] - [Item Count] items"

2. When shopper accepts order, send notification to customer:

• Trigger: When Order → Status changes to "Accepted"
• Send Notification to Order → Customer
• Title: "Shopper Assigned"
• Body: "[Shopper Name] is shopping for your order"

3. When order is completed, send completion notification:

• Trigger: When Order → Status changes to "Completed"
• Send Notification to Order → Customer
• Title: "Order Delivered"
• Body: "Please rate your experience"

Learn more about setting up push notifications in Adalo.

Using Custom Formulas for Order Totals and Fees

Add calculation logic using Adalo's formula builder:

1. In Orders collection, set Total Amount as calculated property:

• Formula: Subtotal + Delivery Fee + Service Fee + Tax Amount

2. Set Subtotal as calculated property:

• Formula: Sum of all related Order Items → Line Total

3. Set Tax Amount as calculated property:

• Formula: Subtotal * 0.08 (8% tax rate)

4. For distance-based delivery fees, create formula:

• If Distance < 3 miles: $5
• If Distance 3-7 miles: $7
• If Distance > 7 miles: $10
• Implementation: Use nested IF statements in custom formula

5. Add surge pricing logic:

• Create Surge Multiplier property (Number)
• Set based on time of day or pending order volume
• Update Total Amount formula: (Subtotal + Fees) * Surge Multiplier

Custom formulas run automatically whenever related data changes, keeping totals accurate without manual recalculation.

Connecting External Services: Zapier and API Integrations for Delivery Apps

Adalo supports integrations with Zapier, Make, Xano, and Airtable, plus API integration for external data sources, enabling you to extend delivery app functionality beyond built-in features (Professional+ plans).

Setting Up Zapier for SMS Order Notifications

1. Create a Zapier account

2. Create a new Zap with these steps:

• Trigger: Adalo → New Record in Orders collection (filter by Status = "Pending")
• Action: SMS by Zapier → Send SMS
  
  • To: Order → Customer → Phone Number
  • Message: "Your order #[Order Number] has been placed. We're finding a shopper."

3. Create another Zap for shopper notifications:

• Trigger: Adalo → Updated Record in Orders (filter by Status changed to "Accepted")
• Action: SMS by Zapier → Send SMS
  
  • To: Order → Customer → Phone Number
  • Message: "[Shopper Name] is shopping for your order. Track progress in the app."

4. Connect delivery confirmation:

• Trigger: Adalo → Updated Record in Orders (Status = "Completed")
• Action: SMS by Zapier → Send SMS
  
  • To: Order → Customer → Phone Number
  • Message: "Your order has been delivered! Please rate your experience."

Zapier automation runs in the background without requiring app updates.

Using API Integration for Inventory Management

Connect to external inventory systems using Adalo's Custom Actions:

1. Go to your Store's inventory API endpoint
2. In Adalo, create a Custom Action:
   
   • Name: "Sync Store Inventory"
   • Method: GET
   • URL: Your inventory API endpoint
   • Headers: Include API authentication key
3. Map response fields to Product properties:
   
   • API "stock_level" → Product → Stock Quantity
   • API "available" → Product → In Stock
4. Schedule this action to run every 15 minutes using a Zapier scheduled trigger

For real-time inventory updates, use webhooks from your inventory system to trigger Adalo API endpoints.

Connecting to Airtable or Xano for Advanced Data

For high-volume order processing, consider external collections:

Airtable Setup:

1. Create an Airtable base with Orders and Products tables
2. In Adalo, go to Database → Add External Collection
3. Select Airtable, authenticate, and choose your base
4. Map Airtable fields to Adalo properties
5. Use Airtable for historical data while keeping active orders in Adalo

Xano Setup (Professional+ required):

1. Create a Xano account and database
2. Build API endpoints for Products, Orders, Users
3. In Adalo, add External Collection → Xano
4. Connect Xano API endpoints
5. Benefit from Xano's advanced filtering, serverless functions, and unlimited scalability

Xano integration is particularly valuable when your marketplace grows beyond 100,000 products or 10,000 daily orders, offering the backend power of traditional development with no-code ease.

Testing Your Instacart Clone: Preview and QA Workflows

Adalo's Free plan includes unlimited test apps with the built-in previewer, allowing you to validate on-demand delivery workflows across web and mobile before publishing.

Using the Adalo Previewer Across Devices

1. Click the Preview button (play icon) in the top-right corner
2. Select preview mode:
   
   • Web Preview: Opens browser window showing responsive web version
   • iOS Preview: Shows iPhone-sized viewport
   • Android Preview: Shows Android device viewport
3. Download the Adalo Preview App on your phone:
   
   • iOS: Search "Adalo" in App Store
   • Android: Search "Adalo" in Google Play
4. In preview app, scan QR code from Adalo editor to load your live app
5. Test on actual device hardware to validate touch interactions, GPS, notifications

The previewer updates in real-time as you make changes—no need to republish between edits.

Testing Multi-User Scenarios (Customer and Shopper)

Create test accounts for each user type:

1. Create Test Customer Accounts:

• Sign up with emails like customer1@test.com, customer2@test.com
• Set User Type = "Customer"
• Add test delivery addresses
• Save test payment methods (use Stripe test cards: 4242 4242 4242 4242)

2. Create Test Shopper Accounts:

• Sign up with emails like shopper1@test.com, shopper2@test.com
• Set User Type = "Shopper"
• Complete shopper profile (vehicle, photo)
• Toggle availability to "Available"

3. Test the Complete Flow:

• Log in as Customer → Browse products → Add to cart → Checkout → Place order
• Log in as Shopper → View available orders → Accept order → Update status through completion
• Log in as Customer → Track order → Receive delivery → Submit rating
• Verify each status transition updates correctly
• Check that notifications send at appropriate moments

Validating Payment and Order Flows

Payment testing checklist:

1. Test successful payments:

• Use Stripe test card: 4242 4242 4242 4242 (any future expiry, any CVC)
• Verify order total calculates correctly
• Confirm Payment record creates with correct amount
• Check Order → Payment Status updates to "Paid"

2. Test payment failures:

• Use Stripe decline card: 4000 0000 0000 0002
• Verify error message displays
• Confirm order doesn't proceed without payment
• Check that user can retry payment

3. Test saved payment methods:

• Save card during checkout
• Place second order using saved card
• Verify faster checkout experience

4. Validate commission calculations:

• Create test orders at different stores
• Calculate expected retailer payment: Order Total × (1 - Commission Rate)
• Verify your platform fee: Order Total × Commission Rate

Use the preview mode to simulate different scenarios: order cancellations, out-of-stock items, substitutions, delivery delays, and rating submissions.

Publishing Your On-Demand Delivery App to Web, iOS, and Android

Adalo publishes directly to the web (Starter+ plans with custom domains), Apple App Store, and Google Play Store, with manual publishing control that lets you update apps without disrupting users.

Publishing to Web with a Custom Domain

1. Upgrade to Starter plan or higher ($36-45/month)
2. Purchase a custom domain (e.g., freshcart.com) from registrars like Namecheap or GoDaddy—domains cost $10-45/year
3. In Adalo editor, go to Settings → Publishing → Web App
4. Click "Publish to Web"
5. Enter your custom domain
6. Follow DNS configuration instructions:
   
   • Add CNAME record pointing to Adalo's servers
   • Wait 24-48 hours for DNS propagation
7. Enable HTTPS (automatic with Adalo hosting)

Your web app is now live and accessible via browser on any device. Updates publish instantly—click "Publish" to push changes live without downtime.

Submitting to Apple App Store: Requirements and Process

Prerequisites:

• Apple Developer Account: $99/year license
• Mac computer with Xcode installed (or use Adalo's managed build service)
• App icons in required sizes (1024×1024 and various smaller sizes)
• Screenshots for App Store listing (iPhone and iPad sizes)
• Privacy Policy URL (required for food delivery apps)

Submission steps:

1. In Adalo, go to Settings → Publishing → iOS
2. Fill in app information:
   
   • App Name (max 30 characters)
   • Bundle ID (e.g., com.yourcompany.freshcart)
   • Version number (start with 1.0.0)
3. Upload app icon and screenshots
4. Click "Build iOS App" (Adalo generates the app bundle)
5. Wait 20-40 minutes for build completion
6. Download the .ipa file or publish directly via App Store Connect
7. In App Store Connect:
   
   • Create new app listing
   • Upload your build
   • Fill in app description, keywords, category (Food & Drink)
   • Add privacy policy URL
   • Submit for review

Apple review typically takes 1-3 days. They check for quality, safety, and compliance with App Store guidelines. Food delivery apps must clearly disclose fees, have working payment systems, and include customer support contact information.

Learn more about publishing to iOS.

Launching on Google Play Store

Prerequisites:

• Google Play Developer Account: $25 one-time fee
• App icons (512×512 high-res icon)
• Feature graphic (1024×500 pixels)
• Screenshots (at least 2, max 8)
• Privacy Policy URL

Publication process:

1. In Adalo, go to Settings → Publishing → Android
2. Fill in app details:
   
   • Package name (e.g., com.yourcompany.freshcart)
   • Version code (1) and version name (1.0.0)
3. Upload icons and graphics
4. Click "Build Android App"
5. Wait 20-40 minutes for APK/AAB generation
6. In Google Play Console:
   
   • Create new app
   • Upload your app bundle (AAB file)
   • Complete store listing with description, screenshots, category
   • Set content rating (fill questionnaire—likely PEGI 3 for grocery delivery)
   • Add privacy policy URL
   • Submit for review

Google review is typically faster than Apple (1-2 days). Once approved, your app appears in Google Play Store within hours.

Check Adalo's Android publishing guide for detailed instructions.

Important: Both app stores require compliance with food safety regulations, transparent fee disclosure, and data privacy standards (GDPR/CCPA). Include terms of service and clearly communicate all charges before checkout.

Scaling Your Delivery App: Performance, Storage, and Plan Upgrades

Adalo handles over 20 million data requests daily with 99%+ uptime, and Team/Business plans offer unlimited editors, priority support, and Xano integration for scaling on-demand delivery platforms.

Understanding Adalo Plan Limits for Growing Delivery Apps

As your marketplace grows, monitor these metrics:

Free Plan Constraints:

• 200-500 database records total (across all collections)
• 1 editor account
• Web publishing on Adalo subdomain only
• No custom branding
• Standard support

When to upgrade from Free to Starter ($36-45/month):

• You exceed 500 total records (products + orders + users)
• You need custom domain for web app
• You want to publish native mobile apps
• You require custom branding (logo, colors)

When to upgrade to Professional ($52-65/month):

• You need geolocation for delivery tracking
• You want to integrate with external APIs (inventory systems, SMS)
• You need 25GB file storage for product images
• You have multiple team members requiring editor access (up to 5)
• You want to publish 2 apps (customer app + shopper app)

When to upgrade to Team ($160-200/month):

• You need 5 published apps (customer, shopper, retailer, admin, driver)
• You require 10 editor seats for development team
• You want priority support response
• You need Xano integration for advanced data scaling

When to upgrade to Business ($200-250/month):

• You manage 10+ published apps across markets
• You need unlimited editors for large organization
• You want special add-on pricing for extra apps/storage

Upgrading to Professional or Team Plans

Upgrade process:

1. Go to Adalo pricing page
2. Click "Upgrade" on desired plan
3. Enter payment information
4. Select billing cycle:
   
   • Monthly: $45, $65, $200, or $250/month
   • Annual: Save 20% ($36, $52, $160, or $200/month billed annually)
5. Plan upgrades take effect immediately—no app downtime
6. Existing apps continue running during upgrade

No refund policy: Adalo doesn't provide refunds for your current billing cycle when downgrading/cancelling, so plan carefully before upgrading.

Leveraging Xano for High-Volume Database Needs

When you reach these thresholds, consider external database integration:

• 100,000+ products across multiple retailers
• 10,000+ daily orders
• 50,000+ registered users
• Complex data relationships requiring advanced queries
• Need for serverless functions and business logic

Xano integration benefits:

1. Unlimited scalability: Handle millions of records without performance degradation
2. Advanced filtering: Complex queries, full-text search, aggregations
3. Serverless functions: Custom business logic, data transformations, scheduled tasks
4. API first: Build once, connect to multiple platforms
5. Real-time updates: Webhook-driven data synchronization

Setup Xano:

1. Create Xano account at xano.com
2. Build database tables matching your Adalo collections
3. Create API endpoints for CRUD operations
4. In Adalo, go to Database → Add External Collection
5. Select Xano, authenticate, connect endpoints
6. Map Xano fields to Adalo properties
7. Use Xano for historical data, keep Adalo for active sessions

This hybrid approach maximizes Adalo's visual builder strengths while leveraging Xano's database power for scale.

Why Adalo Is the Right Choice for Building Your Grocery Delivery Marketplace

The convergence of explosive grocery delivery growth ($13.9B to $45B by 2035) and mainstream no-code adoption (65% of all app development by 2024) creates an unprecedented opportunity. Adalo positions itself as the most accessible entry point to this market.

Economic Advantage: Traditional marketplace development requires $70,000-$100,000 in capital. Adalo reduces this by 65-70%, enabling entrepreneurs to launch functional MVPs for annual subscription fees of $216-$300. The platform's visual builder delivers apps 56% faster than traditional development—compressing 6-12 month timelines into 4-8 weeks.

Technical Completeness: Unlike website builders attempting app creation, Adalo was purpose-built for mobile-first applications. The platform provides everything delivery marketplaces require: Stripe Connect for split payments, cross-platform deployment (iOS, Android, web from a single build), built-in relational database, user role management, geolocation tracking, and external integrations with Zapier, Xano, and Airtable. This eliminates the technical barriers that historically restricted marketplace creation to well-funded startups.

Proven Performance: Adalo's infrastructure processes over 20 million data requests daily with 99%+ uptime, demonstrating production-grade reliability. The platform has enabled 1M+ apps serving 2M+ end users—proving that no-code architecture can support real businesses at scale.

Growth Pathway: Start with the Free plan to validate marketplace mechanics, upgrade to Professional ($52-65/month) for geolocation and payments, then scale to Team/Business plans as your operation grows. The Adalo Component Marketplace continuously expands functionality, while integrations with Xano and external databases future-proof your architecture for high-volume growth.

If you can make a slide deck, you can build a grocery delivery marketplace—Adalo removes the technical complexity that once made multi-sided platforms accessible only to engineers.

Explore Adalo's app templates and cloneable kits for additional inspiration, or browse the Made in Adalo showcase to see real delivery apps built by the community.