TechEquity RAD · For Enterprise Engineering Organisations
One Platform.
Every Team.
No Reinvented Wheels.
A governed deployment catalogue for organisations
where the same infrastructure is being built many times over.
In an engineering organisation of any size, the cost of undifferentiated infrastructure is not
one team's three days — it is every team's three days, repeated, diverging, and impossible to
audit afterwards. RAD gives all of them the same reviewed catalogue, deployed into your own
Google Cloud organisation, under your own policies, with an audit trail behind every action.
350+ Reviewed Modules
60+ Composed Solutions
Your Org, Your Policies
Role-Based Access
60+
Multi-module solutions
20%
Volume credit discount
Standardisation is not a mandate you announce. It is the easiest path you offer.
The Cost of Undifferentiated Engineering
The Same Work,
Multiplied by Every Team You Have.
A single team building its own database, ingress and secrets handling is a defensible use of
three days. Forty teams doing it independently is a platform problem wearing a delivery
problem's clothes — and the second-order cost is not the time, it is the divergence.
Duplication
The same infrastructure, authored independently. Each team
writes its own Terraform for the same managed database and the same ingress, because
finding and adapting another team's is slower than starting fresh.
Divergence
Forty variants of one pattern. Different provider versions,
different naming, different opinions about what belongs in a secret. Every variant is a
separate thing to review, patch and eventually migrate.
Review load
Security reviews that never converge. A platform or security
function reviewing bespoke infrastructure per team is reviewing the same decisions
repeatedly, and catching the same omissions.
Opacity
No single answer to "what is deployed, by whom, and what does it
cost?" The information exists, spread across project inventories, ticket systems
and people's memories.
Golden paths fail when they are slower than the alternative. An internal
platform only standardises behaviour if using it beats writing your own. RAD is built to be
the faster option on day one — a catalogue entry deploys in about twenty minutes of build time,
which no team can match by authoring from scratch.
What changes when the catalogue is shared
1
One reviewed implementation
A module is reviewed once and deployed many times. A fix to the pattern reaches every
future deployment of it, rather than forty repositories.
100%
Attributable spend
Every deployment carries its owner, its cost and its audit trail. Credit consumption is
recorded per action, so chargeback is a report rather than an investigation.
0
New runtime dependencies
RAD is not in the request path. It applies Terraform and leaves. A deployment keeps
running unchanged whether or not anyone signs in to RAD again.
Deployed Into Your Organisation,
Governed by Your Rules.
RAD does not ask you to move workloads to someone else's account. The default model is
bring-your-own-project: your Google Cloud organisation, your billing account, your org policies,
your VPC, your full region list. RAD holds a deployment identity and nothing else.
Your project
The enterprise default. RAD deploys into projects you
already own and govern. Your organisation policies apply unchanged — RAD cannot widen
them, because it is subject to them like any other principal.
RAD-managed
For evaluation and short-lived work. A guardrailed project
in a dedicated folder, with a spend budget, a restricted API allowlist and a pinned
region set. Useful for proofs of concept that should not touch production estate.
Either way
Terraform state in Cloud Storage, outputs returned to you.
Nothing about a deployment is hidden behind the platform, and nothing stops you managing
it directly afterwards.
Least privilege, enforced server-side
Every request is authenticated and authorised against server-held state, never against
anything the browser sends. Reads are scoped to the caller; all writes go through the
privileged backend. Destructive operations require ownership, not merely visibility.
Audited by default
Money-bearing and privileged actions write an audit record — who, what, when, and against
which deployment. Cross-tenant reads by a support operator are recorded even when the read
was legitimate.
Separation of duties, built in
- User — deploys and manages only their own deployments
- Admin — full estate visibility, settings and catalogue control
- Trainer — provisions environments for a named roster, nothing else
- Finance — credit grants, invoices and revenue reporting
- Support — scoped to the customers whose tickets they hold, and excluded from secrets and destructive actions
- Partner / Agent — publish modules or introduce accounts, with revenue share
Support access expires with the ticket. An operator sees a customer's
deployments only while an assigned ticket is open; resolving it ends the access and reopening
restores it. Visibility is derived from work in progress rather than granted permanently — and
the same rule is enforced in the database, not only in the interface.
Cost control that acts, not just alerts
Budgets on managed projects
Each RAD-managed project carries a spend budget by tier. A sandbox is not permitted to
quietly become a production bill.
Automatic billing enforcement
A reconciler runs continuously: if a managed project's purchased-credit balance goes
negative, its billing is disabled and re-enabled on top-up. The control acts on its own
rather than paging someone.
Whole Stacks,
Wired and Sequenced.
A single module is rarely a system. RAD's 74 pre-composed solutions deploy many modules as one
ordered unit — each wave released as its prerequisites complete, and each consumer receiving its
producer's real outputs automatically. This is the capability most deployment catalogues do not
have.
Wave 1
Foundations
Databases, search, caches and identity provision first, in parallel.
Wave 2
Services
Application services start as their own prerequisites reach success.
Wave 3+
Front ends
Interfaces and gateways receive endpoints and credentials from below.
Teardown
Reverse order
A prerequisite is destroyed only once everything inside it has gone.
What "wired" actually means
- Producer outputs become consumer configuration. A search cluster's real endpoint is written into the application that needs it, at the moment the wave advances — not typed in by hand afterwards.
- Dependencies are per-module, not per-wave. A component waits for the specific things it needs, so an unrelated slow sibling never blocks it.
- Members provision concurrently within and across waves, up to a controlled parallelism limit.
- Teardown respects the same graph in reverse. A shared database cannot be destroyed while a live service still depends on it.
Ordering is the hard part, and it is where hand-rolled automation fails.
Destroying a project ninety seconds before the services inside it finish their own teardown
leaves failures whose resources are already gone. RAD parks a prerequisite's teardown until
every dependent has reached a terminal state.
Bundle pricing
Solutions are discounted by size, because a larger commitment should cost less per part.
| Modules | Discount |
|---|
| 3 – 4 | 15% |
| 5 – 6 | 20% |
| 7 or more | 25% |
Representative solution shapes
Private AI assistant stack
Self-hosted developer platform
Customer support desk
Analytics & product telemetry
Document & contract workflow
Identity & access foundation
Knowledge base & search
Team collaboration suite
+ 66 more
60+ composed solutions as at August 2026, spanning up to 8 dependency-ordered waves.
Consumption Pricing,
With a Volume Curve.
RAD is priced in credits at ten credits to the dollar. There is no per-seat licence — an
organisation of four hundred engineers pays for what it deploys, not for who might. Volume is
rewarded through the plan ladder rather than negotiated per head.
| Plan | Per month | Credits included | Effective rate | Saving | Typical fit |
|---|
| Pay as you go | — | — | $0.1000 | — | Evaluation |
| Starter | $20 | 210 | $0.0952 | 4.8% | A single team trialling |
| Pro | $75 | 825 | $0.0909 | 9.1% | One active product team |
| Business | $250 | 2,875 | $0.0870 | 13.0% | A division running GKE workloads |
| Scale | $600 | 7,500 | $0.0800 | 20.0% | Platform-wide adoption |
Purchased credits do not expire
Budget allocated in one financial period remains spendable in the next. An unspent
balance is not forfeited, so procurement can buy on your calendar rather than ours.
Charged on actual build time
Build metering is 60 credits per hour of real build, plus a module fee in Advanced mode
banded by complexity from 40 to 300 credits. A failed build does not carry a module fee.
Adoption without a migration project
Week 1
One team, one project
Free credits, an existing non-production project, no procurement.
Week 2–4
A real solution
Deploy a multi-module stack the team would otherwise have built.
Month 2
Roles and reporting
Finance, support and admin separation; chargeback from the credit ledger.
Month 3
Catalogue as default
Publish your own internal modules alongside the public catalogue.
Your own modules, in the same catalogue. An internal pattern your platform team
already maintains can be published to RAD and deployed by every team through the same
interface, with the same auditing — and, if you choose to publish it publicly, the same 25%
revenue share any partner receives.
01
Technical evaluation
A working session against one of your own projects, deploying a solution your teams recognise.
sales@techequity.cloud →
02
Assisted deployment
Fixed-fee engineering support: $500 for a Cloud Run deployment, $1,500 for GKE.
Request a quote →
03
Start immediately
300 credits on signup. No payment method, no contract, no sales process.
radmodules.dev →