No-code tools grew significantly in popularity, and now power many modern products and applications. Startups leveraged them to the fullest to launch and iterate their products quickly. And enterprises use them extensively to digitize and optimize internal processes.
When it comes to your no-code application, it can be split into 2 main parts:
- Backend (with the database and key logic).
- Frontend (UI that displays the data and allows your users to consume the content and make actions).
Whether you want to build a quick MVP as quickly as possible or a production-ready service with your database in your location, no—code backends get yocovered.
Some no-code tools offer both of these solutions (like Bubble, Adalo, Glide). Others — only one part (for example, WeWeb or AppGyver have only the frontend part).
Even though that building a product with the frontend and backend together is faster and simpler, there are many cases when you’d need to split them. For example, to meet regulatory requirements (GDPR), or if the stakeholder wants to use a specific type of database (like Postgres).
Under “no-code backend” I mean the solution that meets the following requirements:
- Primarily no-code / low-code.
- Has database (persistent storage to store data).
- Has API to access/modify the data (preferably REST)
- Has the option to define logic / operations if needed.
- (Preferably) Has the option to authorize users and limit access to the data based on user authorization status, role, or other conditions.
Let’s see some of the solutions in action.
Airtable / HeadlessCMS
Airtable offers the database, wonderful UI to view / edit it, and forms to submit new rows. Also, it has a well-documented and flexible API.
To start using Airtable API:
- Go to airtable.com/account, and copy your API_KEY.
- Use it to authorize your requests (with the header “Authorization: Bearer API_KEY”)
- Go to airtable.com/api, select the table you want to access, and the request you want to make.
With Airtable Automations and Integrations, you can make achieve quite a lot of customization and implement pretty advanced logic.
However, Airtable has 2 big limitations:
- Rate limit of only 5 requests per second (it’s enough for a small number of users, but if hundreds of users interact with your database, it would become an issue).
- No Authorization for end users (users cannot sign up / log in, and thus you cannot limit access to certain records based on the authorization status).
Similar to Airtable also functions the category of products Headless CMS, such as Strapi, Contentful, Storyblok. With them you can also define your data structure, and get an API to access/modify it. It’s useful for CMS-like collections where authorization* is not required (like blogs, public receipt books, listings, job posts, etc.).
* Even though some of them (like Strapi) support end-user authentication.
I’d give Airtable API: 9 / 10 ⭐
Bubble Data API
We at Sommo use Bubble together with their UI builder. But Bubble can also be used as a standalone backend solution, using their data models and Bubble Data API (docs).
To use Bubble as backend:
- Upgrade the app to the paid plan.
- only apps on the paid plan can use Data API.
- Enable Data API and Workflows.
- Generate API Token
- And keep it secure, it’s for Super Admin only, cos the API Token gives access to all the database without any restrictions.
- Create Workflows to /login and /signup users.
- If you use “Login” or “Sign up” actions in the Bubble backend workflows, you’ll get a user access token as a response. Save this token, it will be the user authorization method. (see docs).
- Authorize users using workflows.
- Sign them up and log in. Note: you’ll need also to regularly update the access token with the refresh token.
- Make API requests with the user access token.
- Set up Privacy Rules.
- So that users have access only to models that they should have access to.
In this video, we show how to use Bubble as a standalone backend solution, using their data models and Bubble Data API.
The drawbacks of Bubble Data API:
- You cannot choose the location of your DB.
- Well, in theory, you can, by selecting the enterprise plan and moving your whole Bubble app to a separate instance in the desired location. But it costs thousands of dollars per month, which is too expensive for most users.
- Data API is limited.
- Especially it’s hard to search/query collections with their “search constraints” (see docs).
My review for Bubble Data API: 8 / 10 ⭐
Supabase
Supabase is an open source solution that offers Postgres database, Authentication, instant APIs, Edge Functions, Realtime subscriptions, Storage, and more.
I love that Supabase is built on top of standard Postgres database, you can choose where to deploy it, to which you can connect, write SQL queries, view tables, etc. It’s very intuitive, has wonderful documentation, lots of examples and cases. And they have affordable pricing (free, then starting at $25 / month).
To start using Supabase:
- Create tables and schemas (private or public).
- Define auth provider (email/password, magic link, Google/Facebook, etc).
- Get Service key.
- Like Bubble’s API Key, it gives unlimited access, so use it wisely and keep secured.
- Authorize users through their API, get user token.
- Supabase uses standard JSON Web Token (jwt), that you can check on https://jwt.io/
- Make API request with user auth token.
- Supabase uses PostgREST api (docs). It’s very simple and intuitive, yet powerful. Allows you to quickly filter / select data, just adding, for example “?id=gt.1&id=lt.100&select=price,id” to the URL).
- Define Row Level Security (RLS) policies (see docs).
- Supabase uses standard Postgres policies, which are very flexible and powerful. You can easily set up limits to from simple such as “allow to insert rows only authorized users with role = ADMIN”, to more complex, like “allow only members of the team read team messaages”.
In this video, we show how to set up and use Supabase and why it's our top pick ⭐⭐⭐⭐⭐.
The drawbacks of Supabase are:
- Can be harder to get started. Preferably, you’d need to know basic SQL to be able to set up your DB and RLS policies correctly.
- Has some limitations, such as you cannot extend standard “users” table.
They recommend to create a separate own table “profiles”, link it to “users” and keep fields like “firstName”, “lastName” in “profiles”.
I’d give Supabase: 10 / 10 ⭐ (yeah, it’s my top pick).
Firebase
Firebase is a whole app development platform that helps you build … pretty much anything (in theory). It offers authorization, database (option to deploy to many regions), real-time updates, API, hosting, deployment, monitoring, analytics, A/B testing, and many other options.
In our case, we’re interested in Firebase as a no-code backend. To start using Firebase, you need to:
- Create collections.
- Define auth provider (email/pass, magic link, Facebook/Google, etc).
- Get Project key (in project settings)
- Authorize users.
- You’ll be using Google Identity Provider API (docs).
- Make API request with user auth token.
- Here you’ll run into troubles, cos Firebase data API is … well … unique. It has a non-standard format, you’ll find it hard to process responses. And making a query request using their “StructuredQuery” model (docs) is another challenge.
- Define Security Rules (see docs).
This video shows the pros and cons of Firebase as a no-code backend.
The drawbacks of Firebase are:
- Very unique and specific API makes it hard to work with it.
- Filtering collections with “StructuredQuery” is very hard. You cannot even make a simple request with “contains string filter”... it’s a bummer.
- Documentation is complex, poor, with few examples.
- It’s run by Google, and you know that Google tends to kill it’s products (I bet they’d kill Firebase as well sooner or later).
Overall, Firebase is much better to use though their SDKs, or with native integrations (like inside FlutterFlow). But working with it through API is very hard and painful.
I’d give Firebase: 7 / 10 ⭐ .
Xano
Xano position itself specifically as “no-code backend”. It gives you a scalable server (in a chosen location), a flexible database, and a No-Code API builder that can transform, filter, and integrate with data from anywhere.
To start using Xano:
- Create tables and schemas.
- Update standard APIs they give you where needed.
- Most likely you’d want to make most of them protected for authroized users only, filter some data, etc.
- Authorize users through their API, get user token.
- Make API request with user auth token.
That’s it. Xano is probably the easiest to start with. Moreover, Xano has a lot of educational content and resources for any level (from complete beginners to advanced).
Watch our demo video of how to start with Xano as a no-code backend for your app.
The drawbacks of Supabase are:
- Adding logic in the API is limited.
- I’ve found it hard to edit Xano api, combine/filter raws, etc. Their UI editor for this is limited.
- More expensive compared to alternatives (starts from $67 / month).
- I experienced regular bugs, and it stopped working a few times (looks like the product is not polished yet).
I’d give Xano: 8 / 10 ⭐ .
Here is a brief comparison of the tools we have reviewed.
Other tools
There are a lot of other no-code backends; the list above is not exhaustive, of course. Some of the popular ones are:
- Back4App — low-code backend to build modern apps. It’s basically a UI wrapper over open source platform Parase (similar to Firebase in functionality). It’s quite nice, but I didn’t notice any pros compared to Supabase / Firebase.
- Backendless — quite powerful, full stack visual app development platform. But I’ve found it slow, not extensible, and limited.
- Altogic — a very powerful, customizable, and extendable no-code backend (supports many integrations, different environments, queues, cron jobs, caching, has a powerful Navigator and Tester). But it’s quite new, few cases/docs yet. Could be a great solution in a year or two.
Feel free to write in comments or tag us on Twitter with your favourite no-code backend solutions.
Summary
Our recommendations are When you need a no-code backend, go with:
- Supabase + Bubble / WeWeb when you need a web app.
- Firebase + Flutterflow when you need a mobile app.
Our talented team at Sommo can help you select the right stack or help you build the product for you. Don’t hesitate to contact us.
