Create your account
Go to radmodules.dev and sign in. There are two ways in: continue with Google, or create an account with your email address and a password. A password account needs a verified email before it can deploy anything — RAD sends a verification link when you sign up.
- An email address — the one you sign in with, verified if you use a password.
- 300 free credits, added automatically the moment you sign in for the first time.
- 100 more credits a month while you are active (from 1 December 2026, for anyone active in the last 30 days). They reset each month rather than adding up.
Find what to deploy
After signing in you land on the Solutions page. There are two ways to pick what you want:
| Way in | Best for |
|---|---|
| Build Solution with AI | Describe what you need in a sentence ("a help desk for my team") and RAD proposes the applications, explains why, and shows the full price and build time before anything is created. |
| Solution Modules | Browse the catalogue yourself — over 350 ways to deploy more than 190 applications — and pick exactly one module to deploy on its own. |
This guide follows the second path, deploying a single module, since it's the most direct way to see every screen once. Open a module's card and choose Cloud Run or GKE — most applications offer both; Cloud Run is usually the cheaper starting point.
Choose how to configure it
Every module's deploy page offers a choice at the top:
Every setting, grouped and explained
Each page of settings is validated against the module's own rules as you type. This is available to everyone, whatever your credit balance.
Say what you want in plain words
Describe the setting you want changed; it proposes the exact values for you to apply or ignore. This needs purchased credits — a top-up or a subscription unlocks it. On free credits alone, use the Configuration Form instead.
For a first deployment, the Configuration Form is the simpler choice: accept the defaults on each page and only change what you actually need to (a region, a name). RAD's own defaults already follow Google's recommended practice.
Review the confirmation screen
Clicking Deploy Module doesn't start the build right away — it opens a confirmation screen first, so you see the full cost before anything happens.
- Module Type
- Platform Module
- Module Services
- What Google Cloud services it uses
- Credit Cost
- Estimated total for this deployment
- Current Credit Balance
- What you have now
- Available Credit Balance
- What's left to spend, after anything already reserved
This is where the free-credits and purchased-credits paths genuinely differ — not in what you see, but in what happens if your balance is too low.
The screen also shows Purchased Credit Cost. If the module needs purchased credits specifically — the Conversational Assistant, or a handful of other paid features — this is what covers it. Click Confirm and move to step 6.
Most modules deploy fine on free credits alone. If your balance covers the cost, confirm and move on exactly the same way. If it doesn't, you'll see one of two messages:
- Insufficient Credits — your total balance (free + purchased) is too low. Go to step 5.
- Insufficient Purchased Credits — this specific module needs purchased credits, even if your free balance is otherwise high enough. Go to step 5.
Buy credits, if you need to
If you never saw an insufficient-credits message, skip straight to step 6 — nothing here applies to you yet. Otherwise:
- Open the Credits page from the account menu.
- Choose Top Up Credits for a one-off purchase, from as little as US$1 — 10 credits cost US$1 — or a monthly plan if you expect to deploy regularly, which lowers the price per credit.
- Pick your currency and payment method. Card, bank transfer or mobile money, in more than 20 currencies including XAF, XOF, NGN, GHS, KES and ZAR, through Stripe or Flutterwave.
- Pay on the provider's own page. Your card or account details never reach RAD directly, and your credits appear in your balance as soon as the provider confirms the payment.
Once your balance is topped up, go back to the deployment you were confirming and try again; the confirmation screen re-checks your balance automatically.
Confirm and deploy
With the cost and your balance both showing correctly, click Confirm. Credits are charged once, for a successful deployment — if a build fails outright, you are not charged the module fee for that attempt. You're taken straight to the Build Status page.
Watch it build
Build Status streams live logs as your infrastructure is created. A few things are worth knowing before they surprise you:
- "No logs available yet" is normal for the first few seconds — it means the build hasn't started streaming yet, not that anything has failed.
- If a step genuinely fails, a Search for a fix button sends the exact error — not a general description — to Google AI Mode, so the search actually matches your problem.
- Most single-module deployments finish in well under twenty minutes; many finish in a few.
Use what was built
Once the build succeeds, the deployment's Outputs tab shows what to actually use: the application's URL, and any credentials the module generated for you (database passwords, admin logins) — kept out of the page by default and revealed only when you choose to see them.
If you want a plain-language summary of what was actually created, the Explain this button describes it without sending your project or resource names anywhere — it only ever sends the shape of what was built, not identifying details.
Update, pause or remove it
A deployment isn't a one-time thing — you can change it, step away from it, or take it down entirely, from its own page:
| Action | What it does |
|---|---|
| Update | Change a setting and apply it to the running deployment. A change that would destroy and recreate something is flagged, with the setting named, before it runs — nothing destructive happens silently. |
| Delete | Tears down the cloud resources this deployment created. |
| Purge | Also removes the record from RAD, after deleting. Use this once you're certain you won't need the deployment's history again. |
Build your own bundle
A Custom Solution is your own bundle of several modules, deployed together into one project in the right order. Open Catalog → My solutions and describe what you need, the same conversational way as Build Solution with AI — it proposes which modules to include and why, and you accept, drop or ask it to change any of them before saving.
Deploy and manage it
A Custom Solution deploys through the exact same pipeline as any other solution — the same confirmation screen, the same credit rules from step 4, the same build status page. Its modules are built in waves, each one starting once what it depends on has succeeded, recalculated automatically every time you change the solution. Only you can see or edit a solution you've built; nobody else can reach it by its address.
Create a session
From Managed Environments, start a New lab session. You'll set:
| Field | What it controls |
|---|---|
| Session name | What you and participants see, e.g. "Kubernetes fundamentals, March cohort". |
| Participant emails | The roster — up to 1,000 people, added by email. |
| Module or solution | What each participant's own copy will be. |
| Credits per participant | The allowance for one person's environment, from 1 up to 1,000,000. |
| Duration | 15 minutes to 24 hours. |
| Who funds it | You, up front for the whole roster, or each participant from their own credits — fixed when you create the session. |
Creating it shows the total it will reserve before you confirm, the same cost-before-commit pattern as every other deployment on RAD.
What participants get
Each participant signs in with the email you added to the roster and gets their own environment, in their own Google Cloud project — not a shared one. By default they can use it but not change its settings; you can switch on participant deployment for a session if you want them able to deploy within it themselves, within a cap you set.
During the session
You can extend the time, top up credits, export the roster, or end it early, all from the session's own page. An overrun ceiling (20% by default) lets usage run a little past the allowance before anything is cut off, so nobody is dropped mid-exercise over a small overrun.
When it ends
Every participant's environment is deleted automatically, and whatever of your reserved credits went unused comes back to you — settlement can take up to a couple of days while RAD waits for Google's own billing data to catch up. Running the same session again doesn't mean rebuilding it: Duplicate copies the setup (not any secrets it generated) so you can reuse it for the next cohort.
Fund a wallet, create the project
From Managed Environments, fund a ring-fenced wallet from your own purchased credits and create the project for your client inside it. Every module fee, build and hour of Google Cloud usage for that project comes out of this wallet, metered the same way as any RAD-managed project — never out of your general balance.
If the wallet runs low
With about a day of spend left, billing pauses automatically — nothing is deleted, the project's data stays exactly as it is. Topping the wallet back up to roughly two days of spend resumes it without needing to contact anyone. A paused project that stays unfunded for a set grace period (seven days by default) is deleted outright, with a warning the day before — so your client never gets an unexpected charge, and you're never caught by a silent, permanent loss either.
Hand the project over
Request the handover, and RAD waits until every cost already incurred has been metered and settled before completing it — so nothing from your wallet is billed after the fact. The deployments become your client's own from that point, and they'll need their own purchased credits to keep running them. If you're not handing a project over, End project tears it down the same way any deployment does.
Link a project you already own
Managed Billing is for a Google Cloud project that already exists — one you can't pay Google for directly (no card Google accepts, or you'd rather pay RAD in your own local currency), or one you'd simply rather run on the same purchased-credit balance as everything else. Link it, and RAD starts paying Google for it; you prepay credits, and RAD debits them hourly for whatever the project actually uses.
Nothing about the project changes. It keeps its project ID, its data and your full IAM control — including things a RAD-managed project doesn't offer, like the Gemini API. RAD never gets access to your data or resources; the only thing it gains is the ability to attach and detach a billing account.
Request the link
From Credits → Linked Projects, enter the project ID and work through four steps, all on that same page:
| Step | What it involves |
|---|---|
| 1. Confirm you own the project | Add a label to it, as proof of control. Only a project Owner or Editor can do this — the same ownership check used elsewhere on RAD. |
| 2. Let RAD manage the billing link | Run two commands, as a project Owner, granting RAD's billing identity exactly two roles: Browser (read the project) and Billing Project Manager (attach or detach a billing account). Neither gives RAD access to your data or resources. |
| 3. Cap your Gemini API and GPU quotas | In the Google Cloud console (IAM & Admin > Quotas), lower these to what you expect to use. RAD can't set quotas on a project it doesn't own, and Gemini tokens or GPU usage can spend faster than a credit balance can cover. |
| 4. Request the link | Sends it to Finance. You'll see its status on the same page from here on. |
Finance review and the billing account
Before you even request a link, the page states the terms that apply to your account: your VAT rate (set per customer by Finance), what happens with Google's own credits — by default usage is charged at list price with none of Google's free tier, discounts or promotions passed on, unless Finance has agreed otherwise for you — and your floor, the minimum purchased-credit balance you must hold before a request can be approved.
Finance confirms the quota caps from step 3 and checks your balance against the floor before approving. Which Google Cloud billing account actually gets attached is also Finance's call, not a choice you make: most customers are billed from RAD's own shared billing account, but for an account Finance has set up with one, RAD instead uses a dedicated sub-account reserved for that customer — verified to sit under RAD's own reseller account and usable by RAD's billing identity. Either way, you never deal with Google's billing pages directly; RAD does, and settles with you in credits.
You can follow the request's status the whole way — Awaiting approval, then Linking, then Linked once it's live. If Finance can't approve it, the request is Rejected with their reason shown on the same row.
Staying in control
If your purchased balance falls below the floor, RAD pauses automatically by detaching its billing account — RAD emails you first. The project's services stop, but nothing is deleted; buying enough credits to clear the floor again resumes it without you needing to ask.
You can leave at any time, two ways: link your own billing account back onto the project yourself in Google Cloud, or use Stop in Linked Projects to have RAD detach its billing account from it. Throughout, the project is yours — same ID, same data, same console, same IAM. RAD only ever holds the two role grants from step 2 of the request, nothing more.
How credits work
| Source | Amount | Behaviour |
|---|---|---|
| Sign-up | 300 credits | Once, on your first sign-in. |
| Monthly | 100 credits | Monthly for anyone active in the last 30 days (from 1 Dec 2026); resets, does not carry over. |
| Top-up | From US$1 (10 credits/US$1) | One-off purchase; never expires. |
| Subscription | Varies by plan | Lower price per credit than a one-off top-up. |
Free and monthly credits are spent first; purchased credits are kept in reserve for anything that specifically requires them, and never expire.
How roles and access work
Every feature in this guide needs one or both of two things: a role on your account, or purchased credits. Only one of those is ever self-serve.
| Feature | Needs a role? | Needs purchased credits? |
|---|---|---|
| Deploy a single module | No — any account | No, usually — free credits often cover it |
| Conversational Assistant | No — any account | Yes |
| Build Solution with AI / Custom Solutions | No — any account | Yes |
| Create Lab Sessions | Yes — Trainer | Only if you're funding participants yourself |
| Create Client Projects | Yes — Partner | Yes |
| Link a project (Managed Billing) | No — any account | Yes, plus Finance's approval on every request |
Glossary
| Term | Meaning |
|---|---|
| Module | One deployable application or piece of infrastructure. |
| Module fee | A one-off charge, once per deployment, typically US$7.50–30. |
| Build time | Included in the price: no build charge to create, 5 updates a month free per deployment then 2 credits each, and nothing for a delete or a failed build. |
| RAD-managed project | A Google Cloud project RAD creates and runs for you, billed in credits. |
| Your own project | A Google Cloud project you already own; Google bills your own account directly, and RAD charges only the module fee (builds are included). |
| Custom Solution | Your own bundle of modules, composed and deployed together as one unit. |
| Lab Session | A time-boxed cohort of individual environments, created and run by a Trainer. |
| Client Project | A project a Partner runs on a client's behalf, funded from a wallet the partner controls. |
| Linked project | A project you already own, with RAD paying Google for it and debiting your purchased credits; you keep full ownership and control. |
| Floor | The minimum purchased-credit balance you must hold for a linked (or client) project to stay active. |