Skip to content

Account model

Explanation · Updated Sep 2026

Coming from another cloud?

▸AWS·Organizations, IAM Users

AWS Organizationshigh

  • AWS Organizations provides hierarchical OUs, SCPs for governance, consolidated billing; OpenStack lacks native multi-deployment orgs, uses Keystone domains/projects for isolation but no built-in billing consolidation across deployments.
  • Billing model: AWS management account pays for all members; OpenStack billing is provider-specific, often per-project quotas but no standard consolidated billing service.
  • Policies: AWS SCPs limit max permissions; OS uses role assignments without equivalent guardrails.
  • API: AWS CreateOrganization, ListOrganizationalUnits; OS no equivalent, managed via Keystone domains.
AWS docs ↗

IAM Usershigh

  • AWS IAM Users are tied exclusively to one AWS account with no native multi-account scoping without Organizations; OpenStack users exist in domains and get scoped to multiple projects via role assignments, allowing flexible multi-tenancy within a deployment.
  • AWS emphasizes long-term credentials like access keys/passwords but strongly recommends federation/temporary creds for humans; OpenStack uses short-lived, scoped tokens natively.
  • Naming: AWS ARNs like arn:aws:iam::ACCOUNT:user/NAME; OpenStack uses user@domain scoped to project@domain.
  • API differences: AWS uses CreateUser, ListUsers in IAM API; OpenStack Keystone v3 API integrates user/project/role in assignments (e.g., POST /v3/role_assignments).
AWS docs ↗
▸Azure·Subscriptions

Azure Resource Groupshigh

  • Resource Groups store metadata in a specific region and support resources from multiple regions; OpenStack lacks formal grouping beyond projects, resources directly scoped to projects.
  • Built-in features like ARM locks (Read-only/Delete), integrated tags for cost allocation, and deployment history views; OpenStack uses project quotas and locks via extensions, no native group-level deployments.
  • Lifecycle management: Easy group delete/update via ARM templates; OpenStack deletes resources individually or via OpenTofu destroy/Heat stacks scoped to projects.
  • Portal views aggregate metrics/deployments across group; OpenStack Horizon shows per-project.
Azure docs ↗
▸DigitalOcean·Teams

Teamshigh

  • DigitalOcean Teams allow multiple users to share access to one billing account's resources. There is no hierarchy above the team level; Teams cannot be grouped or nested. Quake AI's Organization → Project model provides two levels of isolation.
  • DO Teams use a simple Owner/Member role model for the entire team. OpenStack Keystone roles (admin, member, reader) are project-scoped and assignable per-user per-project for fine-grained access control.
  • All resources created by DO team members belong to the team's account; there is no per-member resource scoping. OpenStack resources belong to a project and users access them through project membership roles.
  • DO Teams have no concept of sub-teams or nested groups. OpenStack supports domain-level user management with project hierarchies (nested projects) in Keystone v3.
DigitalOcean docs ↗
▸Google Cloud·Projects

Projectshigh

  • GCP Projects have both human-readable Project ID (custom) and auto-generated numeric Project Number, used interchangeably in APIs unlike OpenStack projects which use single ID.
  • Projects required to enable billing and host all service resources; no direct equivalent to OpenStack's billing per project without linking to Billing Account.
  • Projects inherit IAM policies from Org/Folders; moving project changes inheritance, unlike flat OpenStack project isolation.
Google Cloud docs ↗

Account model

Quake AI organizes everything you own around three nested ideas: your identity, an organization, and the projects inside it. Resource tiers, team roles, and application credentials all attach to those ideas. This page explains how the pieces relate so the procedures in the rest of the Account & Billing section make sense as a whole. For step-by-step instructions, follow the links in each section.

The three layers#

Your account has three layers, from the outside in.

Rumble.com accountOrganizationTeam membersBilling and subscriptionsProject (region a)Project (region b)Resource tierApplication credentialsResource tier signs inproject roleproject role
Click to zoom
Identity signs in to an organization, which holds region-scoped projects; each project carries a resource tier and its own application credentials

Identity is your Rumble.com account. The same login works across Rumble platforms, and Quake AI authenticates against it. You register with an email and password or through single sign-on (Apple, Google, or Facebook), and you manage two-factor authentication from your Rumble.com security settings.

An organization groups related projects and team members under one billing entity. You create an organization the first time you set up Quake AI. One organization can hold multiple projects, and each project can live in a different region.

A project is the resource and billing isolation unit. It owns the instances, networks, volumes, buckets, and other resources you provision, it carries its own quota, and it produces its own subscription charge. Projects are where you do day-to-day infrastructure work.

Projects are the isolation boundary#

A project is the boundary that owns resources, applies quota, and generates a bill. You pick its region when you create it, and that choice holds for the life of the project. To separate environments such as production, staging, and tooling, you create separate projects rather than partitioning a single one.

For readers coming from AWS, a Quake AI project is the closest analog to an AWS account that sits inside an AWS Organization: it is the unit that holds resources and receives the bill. The organization above it plays the role AWS Organizations plays. The full service-by-service mapping lives in Coming from AWS.

You create and switch projects from the portal. See Manage cloud projects for the procedure.

Resource tiers shape the project subscription#

Each project carries a resource tier, a billing category that bundles a set amount of compute, memory, and storage into a fixed monthly subscription. Quake AI documents three standard tiers:

TiervCPUsRAMBlock storageObject storage
Developer1 shared1 GiB20 GiB NVMeAdd-on
OpenClaw Starter4 shared4 GiB25 GiB NVMeAdd-on
Basic4 dedicated16 GiB50 GiB NVMeAdd-on

The tier sets the project's quota: the total vCPUs, RAM, and storage you can allocate. Within that quota you launch individual instances using flavors (named vCPU, RAM, and disk combinations). You can customize a tier by adding vCPUs, memory, storage, or public IPv4 addresses, and you can upgrade, downgrade, or pause a tier at any time. Pausing reduces billed resources to zero so the project holds its place without a charge.

The resource tiers reference covers the tier specifications and the dedicated-versus-shared vCPU distinction. For current prices, see the pricing reference. The Quake AI pricing page hosts the custom-package slider.

Two levels of roles#

Team members hold roles at two levels: the organization and the project. The two levels answer different questions. Organization roles control who can manage the account, projects, users, and billing. Project roles control what a member can do with the resources inside one project.

You add a member to the organization first, then assign them to specific projects. A member with no project assignment can belong to the organization without touching any project's resources.

Organization-level roles#

You manage these under Organization > Team in the portal.

RoleManage orgManage projectsManage usersBilling access
OwnerFullFullFullView and pay
ManagerFullFullAll except ownersView and pay
MemberViewView (assigned only)ViewNone
Billing AdminNoneViewViewFull

Project-level roles#

You assign these when you add a member to a specific project.

RoleAccess
Project ReaderRead-only access to compute resources (instances, networks, routers, and volumes)
VM AdminRead-write access to compute resources
Object Storage AdminRead-write access to object storage resources
Project AdminRead-write access to both compute and object storage

See Manage your account for inviting members at the organization level and Manage cloud projects for assigning project roles.

Application credentials authenticate workloads#

The role tables above govern people working in the portal and console. Non-interactive workloads use a different mechanism: application credentials.

Application credentials are project-scoped secrets you generate to authenticate CLI tools, CI/CD pipelines, Terraform, and scripts against the OpenStack API. The identity service (OpenStack Keystone) backs them. A credential carries one of three coarse Keystone project roles, admin, member, or reader, which set how much of the project's API the workload can use.

Two properties follow from how application credentials work:

  • Project-scoped. A credential is valid only inside the project that issued it. To limit blast radius, you separate workloads into different projects and issue each its own credentials.
  • Coarse roles, no policy language. Authorization uses the three Keystone roles rather than per-resource policy documents. You express isolation through the project boundary rather than fine-grained grants.

The tools and credentials model explains how application credentials sit alongside API tokens, S3 credentials, and SSH keys. Generate application credentials from the console or CLI per Generate application credentials.

Portal and console divide the work#

Quake AI splits management across two surfaces. You sign in to both with your Rumble.com account.

SurfaceURLWhat you do there
Portalportal.rumble.cloudManage organizations, projects, team members, resource tiers, subscriptions, invoices, payment methods, and help desk
Consolesky.<region>.rumble.cloudProvision and operate resources: instances, networks, volumes, buckets, and Kubernetes clusters

The portal is the management layer above your cloud. It is global and works from any browser regardless of where your resources live. The console is region-scoped: each project opens its own console URL, and you reach it from the project's page in the portal. The portal reference documents the portal views, and the console dashboard covers the quota bars you land on after opening a project.

Where billing fits#

Billing attaches to the organization and breaks out per project. Each project's resource tier and add-ons produce a fixed monthly subscription, and every plan includes unlimited data transfer. Invoices arrive on a monthly cycle, and add-ons such as extra object storage or additional public IPs appear as line items.

How billing works explains the monthly model and what appears on an invoice. The Account & Billing FAQ answers practical questions about payment methods, invoices, and subscription changes.

Was this page helpful?