Adalo vs. AppGyver: Real Tutorial for Indie Hackers

Adalo works well for MVPs with fewer than 5,000 users. AppGyver, however, shut down in 2024. This guide will show how to build a mobile app using Adalo and explain why AppGyver's shutdown matters when choosing tools in 2026.

Photo: Balázs Kétyi on Unsplash

Who this is for: Solo founders who need a mobile app quickly, without coding natively. If you’ve built web apps on platforms like Bubble or Webflow, and you want to test an idea on iOS and Android without hiring a team or learning Swift and Kotlin, this is for you.

AppGyver Is Dead: What Happened and Why It Matters

SAP closed AppGyver in April 2024 (see SAP's official notice). It was a popular, powerful, and free platform for indie hackers until SAP decided it wasn't strategic anymore. Many lost months of work as existing apps stopped functioning.

Here's the thing, this isn't just about one tool. It's a reminder: free platforms owned by large companies come with risks. SAP ended AppGyver to promote SAP Build Apps, a paid service starting at $25 per user per month. Indie hackers can't budget for that, and migrating was not user-friendly.

Adalo is alive and kicking in 2026. It's VC-backed and caters to no-code builders. While it's not free for large-scale use—plans begin at $36/month for published apps—the business model is clear. You only pay for what you use, aligning the company's incentives with yours: release apps, gain users, and grow revenue.

For this tutorial, Adalo is the exclusive tool used. The "vs. AppGyver" part serves as historical context, not a direct comparison. AppGyver's shutdown teaches a lesson: pick tools with viable business models.

Setting Up Adalo and Your First Database

Photo: Growtika on Unsplash

Sign up at Adalo.com. The free tier is for prototyping, not for publishing to app stores. To launch real apps, the Professional plan is needed ($50/month in 2026).

Start by creating a new app and select "Native Mobile App" as the template. Adalo compiles iOS and Android builds from a single codebase—producing real native apps, not just web wrappers.

First, set up your data model. Click "Database" on the left sidebar. Create a collection named Tasks with these fields:

• Title (Text)
• Description (Text)
• Completed (True/False)
• Created At (Date & Time)
• Owner (Relationship to Users collection)

Adalo automatically creates a Users collection when authentication is enabled. The Owner relationship links each task to its creator, which mirrors relational data modeling without needing SQL.

Here's how to configure the relationship in Adalo's UI:

1. Click "Add Property" on the Tasks collection.
2. Choose "Relationship."
3. Select "Users" as the related collection.
4. Choose "Belongs To" (each task has one owner).
5. Name it Owner.

Adalo automatically creates the inverse relationship: each user can own multiple tasks. This mirrors foreign keys in PostgreSQL but is managed visually.

Building the UI: Lists, Forms, and Actions

Create a new screen called "Task List." Add a "List" component from the left panel. Set it up like this:

• Data source: Tasks collection
• Filter: Current User > Tasks (shows only the logged-in user's tasks)
• Sort by: Created At (Descending)

Inside the list, add a "Text" component bound to Title and another bound to Description. Add a "Toggle" component bound to Completed for a simple to-do interface.

Add a floating action button (FAB) at the bottom. Click it, add "Link to Screen," and create a new screen named "Add Task." On this screen, add a "Form" component:

• Collection: Tasks
• Fields to include: Title, Description
• Submit button text: "Create Task"

Here's the critical part that Adalo doesn't document well: manually set the Owner field on form submission. Click the form's submit button, go to "Actions," and add "Update Logged In User's Tasks" with "Current Task" as the value. This ensures the new task links to the current user.

Without this action, tasks get created without owners—they'll appear in the database but not in filtered lists. This is the top mistake beginners make with Adalo relationships.

Adding Authentication and User-Specific Data

Adalo offers a built-in authentication system. Enable it in Settings > App Access > Users. Choose "Email & Password" or "Social Login" (Google, Apple).

Add "Sign Up" and "Login" screens. Adalo provides default forms, but customization is recommended. Here's the setup for a sign-up form:

Fields:

• Email (Text Input, keyboard type: Email)
• Password (Text Input, secure entry: On)
• Confirm Password (Text Input, secure entry: On)

Submit Action:

• "Create New User" (Adalo built-in action)
• Email: Form > Email
• Password: Form > Password
• Logged in: True (auto-login after signup)

Validation: Add a "Conditional Action" before submit:

• IF Password ≠ Confirm Password
• THEN Show Notification "Passwords do not match"
• ELSE Proceed with Create User

This is basic, and Adalo's validation is limited. You can't enforce password complexity rules without custom coding. For an MVP, this suffices. For production, you'll quickly encounter limits.

Publishing to iOS and App Stores: The Real Process

Adalo creates native builds, but publication requires Apple and Google developer accounts. Costs: $99/year for Apple, $25 one-time for Google.

iOS Build Process:

1. In Adalo, go to Publish > iOS.
2. Upload app icon (1024x1024 PNG, no transparency).
3. Set bundle ID (e.g., com.yourname.taskapp).
4. Configure app name, version, and description.
5. Click "Generate Build."

Adalo's build service handles this (no Xcode needed). Build times range from 10 to 20 minutes, resulting in an .ipa file.

Upload to App Store Connect via Transporter (Mac app) or Xcode. Fill out App Store metadata: screenshots, description, keywords. Submit for review.

Apple's review takes 1–3 days. Common rejections for Adalo apps include:

• Lack of functionality: Apple rejects apps that are just basic CRUD lists with no unique value. Add a feature to stand out.
• Missing privacy policy: All apps need one. Host it on a real domain, not a Google Doc.
• Crashes during review: Test on physical devices, not just Adalo's preview. The preview doesn't catch all bugs.

Android Build Process:

The process is similar, but upload to Google Play Console. Google's review is quicker (from 2 to 24 hours) and less strict. A developer account and signed APK/AAB are necessary.

Adalo automates signing. Simply download the AAB and upload it to Play Console.

What Nobody Tells You About Adalo's Limits

Adalo is excellent for MVPs under 5,000 users. Beyond that, performance suffers.

Database limits: Adalo uses a proprietary backend, with no direct SQL access. Complex queries (like joins across 3+ collections, aggregations) are slow or unachievable. If the app requires calculations like totals, averages, or filtered counts across large datasets, external APIs are needed.

A workaround: Adalo supports custom actions via Integromat/Make or Zapier. Syncing data to Airtable or Supabase can help perform queries there. However, this adds latency (2–5 seconds per request) and complexity.

No background tasks: Adalo can't run scheduled jobs or background processes. For tasks like sending daily notifications, updating data on a schedule, or processing webhooks, external services are required. Pipedream (free tier available) has been used to trigger Adalo's API every 24 hours for basic automation.

Custom code is sandboxed: While Adalo allows custom components (React Native), they run in a limited environment. There's no access to native device features like Bluetooth, NFC, or advanced camera APIs. For most apps, this isn't crucial. For hardware integrations, however, it's a dealbreaker.

Version control doesn't exist: Adalo lacks Git-like versioning. If something breaks, restoring from backups is possible, but they're daily snapshots—not granular commits. Mistakes can lead to lost work if backups are outdated.

Why AppGyver was technically superior: AppGyver supported true variables, complex logic, and Firestore/REST integrations. Adalo's logic builder is simpler, limited to if/then conditions and basic list operations. For apps with complex state management or real-time features, Adalo struggles.

Common Mistakes Indie Hackers Make with No-Code Mobile

Mistake 1: Treating no-code like native code. Adalo can't handle apps with 50+ screens, complex navigation, or heavy animations. If the app idea requires Uber-level polish, native development is necessary.

Mistake 2: Ignoring API limits. Adalo's API is rate-limited (500 requests/hour on the Pro plan). Syncing with external services can hit this quickly. Instead of fetching live data each time, cache it locally in Adalo collections.

Mistake 3: Not testing on real devices. Adalo's web preview isn't reliable. Buttons that work in preview might fail on iOS. Forms that render well on desktop can break on Android. Testing on a $200 Android phone and a used iPhone is vital before app store submission.

Mistake 4: Assuming no-code means no learning curve. Adalo's UI is intuitive, but data modeling, user flows, and logic still require a software mindset. For newcomers to app building, budgeting 40–60 hours to properly learn Adalo is wise. Documentation is sparse. YouTube tutorials by "Adalo Experts" offer better guidance.

Mistake 5: Building for scale on day one. Adalo is for validation, not scale. Ship quickly, attract users, and prove the concept. When reaching 5,000 users or requiring custom features, migrate to React Native or Flutter. Avoid over-engineering in Adalo.

FAQ

Can I export my Adalo app to native code?

No. Adalo doesn't allow source code export. Once in Adalo, there's no turning back. If it’s outgrown, rebuilding from scratch is necessary. AppGyver's shutdown was painful due to the absence of a migration path.

How much does it actually cost to ship an app with Adalo?

$50/month (Adalo Pro) + $99/year (Apple) + $25 (Google) = ~$750 for the first year, then $600/year. Include $10–$50/month for external services (Zapier, Airtable) if required. For an MVP with 100 users, this is affordable. For a real business, consider migration costs when outgrowing Adalo.

Is Adalo faster than learning React Native?

For an MVP in two weeks: yes. For a sustainable product: no. React Native takes 3–6 months to learn if familiar with JavaScript, but it provides code ownership. Adalo takes 1–2 weeks but limits growth. Choose based on time frame and tech goals.

What happens if Adalo shuts down like AppGyver?

The app is lost. Adalo is VC-backed (raised $8M in Series A, see Crunchbase), but that's no guarantee. Diversification is key: develop essential business logic outside Adalo (using APIs) to switch platforms if needed.

Next Step: Build Your First Screen Today

Visit Adalo now. Create a new app. Add one collection, one list screen, one form. No planning, no overthinking—just build. More can be learned in 30 minutes of hands-on experience than in hours of reading.

The shutdown of AppGyver emphasizes the importance of tool choices. Adalo is still around in 2026, yet it’s not infallible. Use it to validate ideas, not scale. Once the concept is proven, transition to native development or hire a developer. For now, just ship.

For more insights on building apps without code, check out our article on how to Build a Minimal Blog Using Ghost in 7 Steps. If you're looking for tools to enhance your app's functionality, consider exploring the Best No-Code Form Builders for Indie Hackers in 2026.

---

Editorial note: This article was produced with AI assistance and reviewed by Javier Valencia. Verified facts are distinguished from editorial opinion throughout the text. External sources linked are independent of NewsTide.