On mobile?
Email yourself the setup link so you can finish when you're at your computer.
✓ Email sent! Check your inbox.
× Failed to send. Please try again.
⏱ Too many attempts. Please wait a few minutes and try again.
Write a Node.js function, deploy it inside AppAmbit, and call it from your app. It reaches your database, push and CMS through one authenticated ctx, and scales on its own. Manage it in your dashboard, or let your AI Agent write and deploy it over MCP.
Pairs with your App Database and push notifications. No infrastructure to maintain.
// create_post (HTTP trigger)export const handler = async (ctx) => { const { title, content } = ctx.req.body; if (!title) return { status: 400, body: { error: 'title is required' }, }; const createdAt = new Date().toISOString(); const { results } = await ctx.appambit.db( 'INSERT INTO posts (title, content, created_at)' + ' VALUES (?, ?, ?) RETURNING id', [title, content, createdAt], ); const id = results[0].rows[0].id; return { post: { id, title, content, createdAt } };};
Deploy a version, activate it, call it. That is the whole loop.
Write a handler, deploy it, call it.
Servers to provision or patch.
Scales up under load, to zero when idle.
Usage counts toward your AppAmbit bill.
Write and deploy a function yourself in your AppAmbit dashboard, or ask your AI Agent to do it over MCP. It creates the function, deploys a version, waits for the build, and activates it, then hands you a live endpoint.
Prefer to click? Do the same from the AppAmbit dashboard: create, deploy, activate and read logs for every function.
you › Add an endpoint so users can publish a post.
→ appambit.cloud_code.deploy(name: "create_post", trigger: "http")
Live at /api/fn/create_post. Call it from your app, or run it right here.
Every function receives one ctx object. Through ctx.appambit you reach your data, push and content with no connection strings and no secrets in your code: each call is authenticated and scoped to your app for you.
Run parameterized SQL against your app database. No connection string, no credentials: the call is the connection, scoped to this app.
App Database →Run many statements at once, and wrap them in a transaction so they all land or none do.
Send a push with a plain title and body. AppAmbit builds the FCM and APNs payload for each device.
Push notifications →List, read and publish content entries from inside a function, with the same app-scoped access.
CMS →Config values arrive on ctx.env, secrets on ctx.secrets. Secrets are injected at runtime and never echoed back.
Read the authenticated consumer and write lines to the invocation log, in your dashboard or over MCP.
A Cloud Code function is a small piece of backend that reacts to a trigger and does one job. Here are clear examples, each reading trigger to action.
An endpoint that validates the title and inserts a post, then returns the saved row.
Read your database and return a list built for the signed-in user, in one call.
A cart that changes but never checks out fires a reminder push a few steps later.
Receive a partner webhook and turn it into a published CMS entry, ready for your app.
Use a stored secret to reach a third-party service, then save the result to your database.
Check and clean a row as it changes, before the rest of your app ever reads it.
Each deploy is an immutable version that builds on its own. Activate one to make it live, and activate an older one whenever you need to roll back. No downtime, no redeploy.
A new function starts as an empty draft, bound to your app.
Upload your handler. Each deploy is an immutable version that builds on its own.
Point the function at a version to make it live. Activate an older one to roll back at once.
Call it from your app, fire it on a data change, or run it by hand to test.
Three ways to trigger it
Call it over HTTP from your app. The request lands on ctx.req.
React to a data change. The change lands on ctx.event.
Invoke the active version by hand while you build.
The dashboard keeps the full history. See which version is live, review each build, and activate any earlier one to roll back the moment something looks wrong.
| Version | Active | Build | Checksum | Created | |
|---|---|---|---|---|---|
| v4 | Ready | f708dfa7c9… | 6 days ago | live | |
| v3 | Ready | 3e7c5edbab… | 6 days ago | Activate | |
| v2 | Ready | fbb0b020be… | 8 days ago | Activate | |
| v1 | Ready | cd0e2c9583… | 9 days ago | Activate |
Activate any version to roll back instantly. No redeploy.
Your function reaches your backend, and nothing else. No standing keys, no way out of your own app, and hard limits on every run.
Every ctx.appambit call is authenticated and limited to your app. No connection strings or keys live in your code.
Functions run with a short-lived token. There are no ambient cloud keys and nothing secret written to disk.
Each function has a memory size, a timeout, and per-app rate limits, so a runaway loop cannot run away with your bill.
Write a Node.js handler and deploy it. There is nothing to provision, patch, or keep running.
Functions scale up under load and back to zero when idle. You set memory and a timeout, AppAmbit runs the rest.
Every deploy is an immutable version, so you can activate an older one and roll back in one step.
Reach your database, push, and CMS through ctx.appambit, all authenticated and scoped to your app.
App Database →Keep API keys and config out of your code. Secrets are injected at runtime and never logged back.
Deploy, activate and run from your dashboard, or let your AI Agent do it over MCP.
MCP Agent →Once the function is deployed and active, call it by its slug with CloudCode.call, on iOS, Android, Flutter, React Native, .NET MAUI and Avalonia. The SDK adds the base URL, the auth and the JSON: you pass a body and read response.data. Your map becomes ctx.req.body in the function, and whatever it returns comes back. Full reference is in the docs.
// call your deployed function by its slugCloudCode.call("create_post", body: [ "title": "Hello world", "content": "My first post",]) { response, error in guard let response, error == nil else { return } let post = response.data}
// call your deployed function by its slugCloudCode.call("create_post", mapOf( "title" to "Hello world", "content" to "My first post",)) .then { response -> val post = response.data } .onError { error -> }
// call your deployed function by its slugfinal req = CloudCode.call('create_post', body: { 'title': 'Hello world', 'content': 'My first post',});final res = await req.future;final post = res.data;
import { CloudCode } from "appambit"; const res = await CloudCode.call("create_post", { body: { title: "Hello world", content: "My first post" },});const post = res.data;
// call your deployed function by its slugvar res = await CloudCode.Call("create_post", body: new { title = "Hello world", content = "My first post" });var post = res.Data;
// call your deployed function by its slugvar res = await CloudCode.Call("create_post", body: new { title = "Hello world", content = "My first post" });var post = res.Data;
Start free and deploy your first function in minutes. Write it in your dashboard, or let your AI Agent do it over MCP. No credit card required.
Deploy backend logic, no servers.