# Cloud quickstart

Sign up, compose a stack, and provision a managed Rindle app in a few minutes — then point your code at it. The fastest path from zero to a running, durable Rindle backend you don't operate.

[Rindle Cloud](https://cloud.rindle.sh) runs the authoritative data tier for you: the
`rindle-replicator` write-master, its separately placed [`rindled`](/docs/daemon)
read-follower(s), and their durability — from one follower up to a multi-region,
read-scaled fleet. You bring your [API server](/docs/api-server) and your
[browser client](/docs/client); the engine and the
[correctness contract](/docs/architecture#the-correctness-contract) are exactly the
same as [self-hosting](/docs/deploy#run-it-yourself-or-have-us-run-it), operated for
you.

This page gets you from signup to a running app. [Connect your
app](/docs/cloud-connect) then points your code at it.

## 1 · Sign in and add a card

Create an account at [cloud.rindle.sh](https://cloud.rindle.sh) and add a payment
method. Billing is **usage-based** — you're not buying a fixed plan up front; the
card is the consent to provision real infrastructure. The create form shows an
**estimated monthly price** that updates live as you size your stack, so there are
no surprises before you commit.

## 2 · Compose your stack

Instead of picking a pre-baked plan, you compose a deployment bottom-up, and the
console shows the [rung](/docs/deploy#the-deployment-rungs) it maps to as
you go:

- **Read-followers** — how many [`rindled`](/docs/daemon) read-followers serve reads
  (1 to start). Every deployment also has one `rindle-replicator` write-master feeding
  them and streaming continuous backup to object storage.
- **Follower regions** — place each follower near the users it serves. Followers can
  share a region or spread across Fly regions; the write replicator stays a singleton.

A live topology diagram redraws as you toggle components, so you can see the shape
you're buying. The simplest pick is a write replicator plus **one follower on its own
machine**. That is already the same scalable topology used by a larger fleet: raise the
count and choose regions without replacing the app or changing its endpoints.

> **What's provisionable today:** replicated (one separately placed follower) and
> read-scaled (2–5 followers). All use the same write-master + follower topology; a
> stable fleet endpoint and signed affinity tickets place each browser on one follower.
> The [availability table](/docs/deploy#what-is-available) is the source of truth.

## 3 · Provision

Submit the form and the control plane provisions your app and **converges** it
toward your spec — it doesn't fire-and-forget. The dashboard tracks that live: a
status pill (`provisioning` → `active`), a topology diagram folding your desired
spec together with each node's real power state, and the observed Fly resources as
they come up. The page refreshes itself while it converges.

## 4 · Connect your code

Once the app is **active**, the dashboard's **Connect** panel hands you the live-query,
read-control, and write-master endpoints plus their server-side tokens — with copy-paste
snippets for each. Follow [Connect your app](/docs/cloud-connect) to wire them into the
same SDK you'd use anywhere.

## Next steps

- [Connect your app](/docs/cloud-connect) — point your API server and frontend at the
  managed daemon.
- [Scale & operate](/docs/cloud-scaling) — resize, suspend/reactivate, and what each
  shape costs.
- [The deployment menu](/docs/deploy) — every profile, top down, and what runs it.
- [The three-tier architecture](/docs/architecture) — the local-first shape the whole
  thing is built on.

---

[View this page on Rindle](https://rindle.sh/docs/cloud-quickstart)