Updated
The backend for an app is the server side that handles auth, data, file storage and payments behind an API. With jerrycan, an AI agent generates that backend in Rust — code you own and self-host, speaking standard REST to React Native, iOS, Android, Next.js or Flutter — instead of renting it from Firebase or Supabase.
How it gets built: you describe the app to your coding agent — Claude, Cursor, Copilot — and it assembles those blocks from jerrycan's built-ins as plain Rust in your repository, then deploys the compiled binary to a server you choose, or with instantly hosted Postgres via Render. One conversation; the full walkthrough is here.
jerrycan serves standard REST over HTTPS — so "integration" means your platform's native networking, not a vendor SDK. That's the point: nothing in your app belongs to a platform.
Your React Native app calls the backend with the fetch API it already uses — standard REST endpoints for auth, data, files and payments, no vendor SDK woven through your components. Works identically in Expo.
fetch('https://api.yourapp.com/v1/messages', { headers: { Authorization: `Bearer ${token}` } })URLSession and Codable against typed REST endpoints — the backend is plain HTTPS + JSON, so your Swift models map cleanly and nothing in your app belongs to a platform vendor.
URLSession.shared.data(for: request) // plain HTTPS + JSONRetrofit or Ktor client, your choice — jerrycan exposes standard REST, so the stack you already use for networking is the whole integration. No Google-services plugin, no proprietary datastore.
@GET("/v1/messages") suspend fun messages(): List<Message>Call the API from server components, route handlers or the client — it’s REST, so caching, revalidation and edge rendering all behave exactly as Next.js documents them. Your frontend stays deployable anywhere too.
await fetch(`${process.env.API_URL}/v1/messages`, { next: { revalidate: 60 } })The http or dio package against the same endpoints — one backend serves your iOS and Android builds identically, and your Dart models are just JSON mappings, not generated SDK classes.
await dio.get('/v1/messages'); // same API, both platforms| Firebase | Supabase | jerrycan | |
|---|---|---|---|
| What you get | Proprietary SDKs + a NoSQL datastore on Google’s cloud. | Hosted Postgres platform behind their SDKs and dashboard. | A Rust REST backend your AI builds — code in your repo. |
| Client coupling | Firebase SDKs throughout your app code. | Supabase client libraries throughout your app code. | None — standard REST from any client stack. |
| Where it runs | Google’s cloud only. | Their cloud, or self-host ~10 services. | Any server you choose, or hosted Postgres via Render. |
| Pricing shape | Per-operation metering. | Usage-based tiers. | Free, open source — you pay your own hosting. |
| Exit path | Rewrite your data layer. | Migrate off the platform APIs. | Nothing to exit — you own it from day one. |
Fair note: for a prototype you'll throw away, the hosted platforms' free tiers are genuinely the fastest start — the detailed comparisons say exactly when each one beats us.
It depends on the app’s future. For a throwaway prototype, hosted Firebase or Supabase is fastest. For a product you intend to keep, an owned backend wins on cost and portability: jerrycan gives you auth, data, files and payments as a Rust REST API your AI agent builds — code you own, callable from any client stack.
React Native works with any backend that speaks HTTPS and JSON. Firebase is common but couples your components to its SDKs. A REST backend like jerrycan keeps the integration to the fetch API you already use, works identically in Expo, and the backend itself is open-source code you own and self-host.
If your app has user accounts, shared data, uploads or payments — yes. Purely offline, single-user apps can skip it. The backend is what holds authentication, the database, file storage and your product logic behind an API both your iOS and Android builds share.
The leading open-source app backends in 2026 are jerrycan (Rust, AI-built, one binary you own), Appwrite (Firebase-style platform you operate), PocketBase (single Go binary, great for small apps) and Supabase’s open-source components. jerrycan is the only one designed for an AI agent to build the entire backend as your code.
Yes. jerrycan compiles to a single binary you run on any server with a standard database — or with instantly hosted Postgres via Render if you want the database managed. Self-hosting platform-style alternatives like Appwrite or Supabase means operating their service stack instead of owning code.
Point your AI at jerrycan — one conversation later, your app has auth, data, files and payments on a server that's yours.
