RAD · Rapid Application Deployment

Your first deployment, step by step

From creating an account to a running application — using only the free credits every account starts with, and what changes once you add purchased credits — plus Custom Solutions, Lab Sessions and Client Projects for accounts with access to them. Written against the console as it runs today.

Steps
9
Free credits to start
300 + 100/mo
Typical module fee
$7.50–$30
Smallest top-up
US$1
Everyone starts here
1

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.
No card needed yet. Your free credits are enough to deploy several small applications before you ever have to think about payment — that's what the rest of this guide is about proving.
The catalogue
2

Find what to deploy

After signing in you land on the Solutions page. There are two ways to pick what you want:

Way inBest 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.

Two ways to fill in the form
3

Choose how to configure it

Every module's deploy page offers a choice at the top:

📝 Configuration Form

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.

💬 Conversational Assistant

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.

Before anything is built
4

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.

Deployment confirmation
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.

With purchased credits

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.

On free credits only

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.
Only if step 4 asked for it
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:

  1. Open the Credits page from the account menu.
  2. 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.
  3. 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.
  4. 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.
Test it small first. If you're unsure a payment method will work, a US$1 top-up confirms it before you commit anything larger — top-up credits never expire.

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.

The moment it actually starts
6

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.

Usually a few minutes
7

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.
It's live
8

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.

Keeping it, or not
9

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:

ActionWhat it does
UpdateChange 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.
DeleteTears down the cloud resources this deployment created.
PurgeAlso removes the record from RAD, after deleting. Use this once you're certain you won't need the deployment's history again.
If RAD created the project for you and you only need the deployment occasionally — while you're learning, or for a demo — you can delete the whole project rather than just the module. Google keeps it recoverable for 30 days at no charge, and restoring it within that window normally costs no credits rather than a full redeploy, because nothing was individually torn down. The one thing that doesn't survive that 30 days is anything backed up inside the project itself — keep a copy of anything you'd want back, outside the project, before you delete it. A restore is not guaranteed: Google Cloud's terms do not guarantee that a restored project will be usable, so restoring cannot be relied on to get a deleted project back. Take appropriate backups of your data and configuration before you delete; if a restore fails, redeploy the application and restore its configuration from those backups.
Beyond a single module · open to any user
C1

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.

Needs purchased credits. Composing a solution this way, and the My Solutions composer itself, are both locked behind purchased credits — free credits alone don't unlock them. No special role is needed; any signed-in account with a top-up or a subscription can use it.
Once it's built
C2

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.

Running a cohort · Trainer role required
L1

Create a session

Prerequisite: the Trainer role. This is not self-serve — only an administrator can grant it, on your user account. If the Managed Environments tab doesn't show a way to create a session, you don't have it yet; ask an admin.

From Managed Environments, start a New lab session. You'll set:

FieldWhat it controls
Session nameWhat you and participants see, e.g. "Kubernetes fundamentals, March cohort".
Participant emailsThe roster — up to 1,000 people, added by email.
Module or solutionWhat each participant's own copy will be.
Credits per participantThe allowance for one person's environment, from 1 up to 1,000,000.
Duration15 minutes to 24 hours.
Who funds itYou, 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.

For the people you've invited
L2

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.

While it's running
L3

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.

Afterwards
L4

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.

Deploying for a client · Partner role required
M1

Fund a wallet, create the project

Prerequisite: the Partner role, and purchased credits. Like Trainer, Partner is admin-granted only — you can't request it yourself from the console. Client Projects is also one of the features locked behind purchased credits, so both have to be true before you can start.

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.

Keeping it funded
M2

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.

When the engagement finishes
M3

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.

A project you already own · open to any user
B1

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.

Starting the request
B2

Request the link

Needs purchased credits, and Finance's approval. No special role is required — this is open to any signed-in account with a credit ledger. But RAD doesn't start paying Google the moment you ask: Finance reviews every request, and your purchased-credit balance must clear a minimum floor before they can approve it.

From Credits → Linked Projects, enter the project ID and work through four steps, all on that same page:

StepWhat it involves
1. Confirm you own the projectAdd 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 linkRun 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 quotasIn 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 linkSends it to Finance. You'll see its status on the same page from here on.
Before it goes live
B3

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.

Living with it
B4

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.

Quick reference
i

How credits work

SourceAmountBehaviour
Sign-up300 creditsOnce, on your first sign-in.
Monthly100 creditsMonthly for anyone active in the last 30 days (from 1 Dec 2026); resets, does not carry over.
Top-upFrom US$1 (10 credits/US$1)One-off purchase; never expires.
SubscriptionVaries by planLower 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.

Quick reference
ii

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.

FeatureNeeds a role?Needs purchased credits?
Deploy a single moduleNo — any accountNo, usually — free credits often cover it
Conversational AssistantNo — any accountYes
Build Solution with AI / Custom SolutionsNo — any accountYes
Create Lab SessionsYes — TrainerOnly if you're funding participants yourself
Create Client ProjectsYes — PartnerYes
Link a project (Managed Billing)No — any accountYes, plus Finance's approval on every request
Trainer and Partner are never self-serve. They're granted only by an administrator, directly on your account — there's no request form or upgrade button in the console. If you need either role, ask your account's administrator to grant it.
Quick reference
iii

Glossary

TermMeaning
ModuleOne deployable application or piece of infrastructure.
Module feeA one-off charge, once per deployment, typically US$7.50–30.
Build timeIncluded 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 projectA Google Cloud project RAD creates and runs for you, billed in credits.
Your own projectA Google Cloud project you already own; Google bills your own account directly, and RAD charges only the module fee (builds are included).
Custom SolutionYour own bundle of modules, composed and deployed together as one unit.
Lab SessionA time-boxed cohort of individual environments, created and run by a Trainer.
Client ProjectA project a Partner runs on a client's behalf, funded from a wallet the partner controls.
Linked projectA project you already own, with RAD paying Google for it and debiting your purchased credits; you keep full ownership and control.
FloorThe minimum purchased-credit balance you must hold for a linked (or client) project to stay active.
Top ↑