◈ Torque Self-Service

Deploy governed environments on demand.
Any team. Any stack.

Self-Service turns your Curated infrastructure inventory into a governed catalog that developers, data scientists, QA engineers, solution engineers, and product managers can deploy from, without a ticket, without a wait, and without needing to understand the underlying IaC.

Deploy from wherever your teams already work

Platform teams spend weeks building infrastructure that developers and data scientists need in minutes.
Self-Service closes that gap, permanently.

Every time a developer files a ticket to request an environment, your platform team is doing work that should be automatic. Self-Service turns your governed IaC inventory into a catalog that every team in your organization, engineering, QA, data science, sales engineering, and product, can deploy from, without tickets, without waiting, and without bypassing your governance model. The inventory Curate built becomes infrastructure that anyone can use.

Three platform engineering bottlenecks that scale with your organization, and get worse

These are structural problems that appear in every organization where infrastructure access is still a manual, ticket-driven process.

Every environment request is a manual ticket that lands on the platform team
  • Developers, QA engineers, data scientists, and solution engineers all file tickets for environments, and the platform team processes them manually, one at a time
  • The backlog never clears, because demand always exceeds capacity, and every other priority competes with environment requests
  • Platform teams become the bottleneck nobody talks about until it has already slowed down every team that depends on them
Teams work around the process, creating ungoverned infrastructure debt
  • When the wait is too long, developers provision directly in the cloud console, data scientists spin up ad hoc compute, and solution engineers clone environments manually
  • Every workaround creates unmanaged resources, untracked costs, and governance gaps that accumulate silently across accounts
  • By the time an audit surfaces them, the teams who created them are on different projects and nobody knows what they were for
Environments are inconsistent because they’re built differently every time
  • Without a governed catalog, every manual environment build is a local interpretation of what it should be, with different versions, configurations, and assumptions
  • Staging doesn’t match production. The demo environment breaks the day before the presentation. QA finds bugs that don’t exist in dev.
  • Inconsistency is built in by design, because there is no single source of truth for what each environment should look like

WHAT SELF-SERVICE DELIVERS

Three capabilities that eliminate the infrastructure bottleneck.

Platform teams spend weeks building infrastructure that developers and data scientists need in minutes. Self-Service closes that gap permanently, without removing governance or bypassing policy.

01
The governed catalog

Every environment your organization needs, available on demand

  • Platform teams publish approved environment blueprints assembled from Curated IaC modules, with cost caps, TTL limits, and RBAC controls baked in before any user ever sees them
  • Developers, data scientists, solution engineers, and QA teams browse and deploy with no IaC knowledge, no tickets filed, and no platform team involved
  • For constrained resources such as GPU clusters or specialized compute, teams reserve capacity in advance and receive a confirmed availability window

02
AI Environment Designer

Describe what you need in plain language. The AI Copilot builds it from your actual inventory.

  • When no pre-built blueprint fits, users describe what they need in natural language and the AI Copilot searches the Curated inventory, selects the right IaC modules, maps dependencies, and generates a deployable blueprint
  • No YAML. No Terraform expertise. No custom coding by the platform team. The environment is built from your actual governed assets, not generic templates.
  • The Copilot’s output is only as good as the inventory it works from, and Curate made that inventory complete

The AI Copilot builds from your actual governed assets. Every blueprint it generates respects the dependency relationships Curate mapped and the policies your platform team enforced.

03
Deploy anywhere you already work

Portal, IDE, CI/CD pipeline, ITSM, Slack: the same governed catalog everywhere

  • Self-Service plugs into VS Code, JetBrains, GitHub Actions, GitLab CI/CD, Jenkins, ServiceNow, Jira, Slack, and any Internal Developer Portal built on Backstage or Port
  • Developers request environments from their IDE. Pipelines provision environments automatically as part of the build. Service desks fulfill requests without manual steps.
  • The catalog is everywhere. The governance is always enforced. Adoption is instant because there is nothing new for teams to learn.

From natural language prompt to running environment, in under 3 minutes

Most teams wait days for an environment that should take minutes. This video shows how a developer describes what they need, the AI Copilot builds a blueprint from the governed catalog, and the environment deploys, without a single ticket filed or platform engineer involved.

How it works

From governed inventory to running environment, for anyone in your organization

Six steps. From blueprint creation by the platform team to self-service deployment by developers, data scientists, and solution engineers.

01
Build the blueprint

Platform teams assemble governed environments from Curated IaC modules

Platform engineers use the Blueprint Designer to assemble environments from the IaC modules Curate has already discovered, validated, and indexed. Select the compute, network, storage, and application components. Set the configuration parameters. Apply policy constraints: cost caps, TTL limits, and cloud account restrictions. The blueprint is built from your actual, governed assets, not templates from a generic library.

02
Publish to the catalog

Approved blueprints appear in the Self-Service catalog, visible to the right teams and governed by policy

Once a blueprint is approved, it is published to the catalog and made available to the teams and roles the platform engineer specifies. Role-based access controls determine who can see and deploy each blueprint. Cost policies, approval workflows, and TTL limits are baked in before the blueprint is ever visible to end users. Platform teams define what’s available. Policy defines what’s allowed. Users just deploy. For environments backed by finite resources — GPU nodes, specialized hardware, or capacity-constrained cloud quotas — the catalog supports advance reservation. Users book a time slot, receive a confirmed availability window, and their environment provisions automatically when the slot arrives. No manual coordination. No chasing the platform team to find out when resources are free.

03
Or describe it to the AI Copilot

When no blueprint fits, describe what you need. The Copilot builds it.

Not every environment fits a pre-defined blueprint. A developer might need a specific database version combination. A data scientist might need a custom GPU configuration. Using the AI Environment Designer, they describe what they need in natural language. The AI Copilot searches the Curated inventory, selects the right modules, maps dependencies, and generates a deployable blueprint, respecting the policies and governance constraints the platform team configured.

The AI Copilot builds from your actual governed assets. Its output is only as complete as the inventory Curate built, which is why Curate has to come first.

04
Deploy from anywhere

One click from the portal, the IDE, or the pipeline: the same governed deployment every time

Users deploy from wherever they work: the Torque portal, VS Code, JetBrains, GitHub Actions, GitLab, Jenkins, ServiceNow, Jira, Slack, or any Internal Developer Portal. The deployment wizard collects only the inputs needed. No credentials, no IaC files, no cloud console access. For resource-constrained environments, the wizard shows current availability and offers a reservation option — users pick a time slot and get a confirmed booking rather than an uncertain wait. The platform team’s governance rules are enforced before launch: cost caps, approval workflows where required, and TTL limits. The deployed environment is identical to every previous deployment of the same blueprint.

05
Work in the environment

Every team gets what they need. Platform teams see everything that’s running

Once deployed, the environment is live and governed. This applies equally to development environments, QA stacks, staging systems, and production workloads. Users access it through their preferred tools. The platform team sees every active environment in the Operate dashboard: who owns it, what it costs, when it was deployed, and when it expires. Shared environments allow teams to collaborate on a single provisioned stack rather than duplicating resources. Notifications alert users when environments are approaching their TTL, so nothing is silently abandoned.

06
Automatic lifecycle management

Environments that expire on schedule, not silently abandoned and forgotten

Every environment deployed through Self-Service has a lifecycle. TTL-based auto-expiry ensures environments don’t run indefinitely and accumulate cost. Users receive advance notification before expiry, with the option to extend if needed and approval required for extensions beyond policy limits. When an environment reaches its end of life, it is terminated cleanly, resources are released, and cost attribution is recorded. Nothing is left running that shouldn’t be.

This is where Self-Service hands off to Operate. Everything running in a Self-Service environment is monitored, governed, and managed through the Operate layer.

Frequently Asked Questions

A blueprint is a governed, reusable environment definition assembled from IaC modules in the Curated inventory. It defines the components of an environment: compute, network, storage, and application layers, along with the configuration parameters users can set, the policy constraints that govern the deployment (cost caps, TTL limits, cloud account restrictions), and the RBAC controls that determine who can deploy it. A blueprint is the unit that platform teams publish and end users consume.

The AI Environment Designer allows users to describe an environment in natural language — “a web application stack with a load balancer, two app servers, and a Postgres database on AWS” — and the AI Copilot searches the Curated inventory, identifies the right IaC modules, maps their dependencies, and generates a deployable blueprint. The blueprint is built from your actual, governed assets, not generic templates. The quality and accuracy of what the Copilot generates is directly tied to the completeness of the Curate inventory it works from.

Anyone your platform team grants access to. Self-Service uses role-based access controls to determine who can see and deploy each blueprint. Platform teams configure which teams, roles, and users have access to each blueprint when they publish it. Developers, data scientists, QA engineers, solution engineers, and product managers can all use Self-Service — with each group seeing only the blueprints relevant to their work.

Governance in Self-Service is enforced at the blueprint level, before deployment, not after. Platform teams configure cost caps (maximum spend per environment), TTL limits (maximum runtime), cloud account restrictions (which accounts the environment can deploy to), and approval workflows (whether certain deployments require sign-off before they proceed). These constraints are baked into the blueprint. Users cannot override them. Every deployment is policy-compliant by construction.

Yes. Self-Service integrates with Backstage, Port, and OpsLevel via the Torque API, making the catalog and deployment workflow available inside your existing IDP. It also integrates with VS Code and JetBrains IDEs, GitHub Actions, GitLab CI/CD, Jenkins, Azure DevOps, ServiceNow, and Jira. The Self-Service catalog is not a destination; it’s a capability that plugs into wherever your teams already work.

Environments deployed through Self-Service have TTL-based auto-expiry. Users receive advance notification before an environment expires and can request an extension, subject to policy limits. When the TTL is reached, the environment is terminated cleanly: all resources are destroyed, costs are attributed, and a record is written. If an extension requires approval, the workflow is handled automatically. Nothing is left running silently.

Yes. Self-Service is not a pre-production-only tool. The same governed catalog that serves development and QA can serve production workloads, with the appropriate policy guardrails applied at the blueprint level. Production blueprints can require approval workflows before deployment, enforce stricter cost and TTL policies, restrict which cloud accounts they deploy to, and require mandatory tagging for cost attribution and compliance. The governance model scales to production requirements without requiring a different tool or process.

Yes. For environments backed by finite or constrained resources — GPU clusters, specialized hardware, or capacity-limited cloud quotas — Self-Service supports advance reservation. Users browse available time slots directly in the catalog, book the capacity they need, and receive a confirmed availability window. The environment provisions automatically when the reserved slot arrives. This eliminates the uncertainty of queuing for shared resources and gives teams a predictable schedule for when their environment will be ready, without any manual coordination with the platform team.

Try it yourself

Deploy a governed environment in a live playground

No installation. No configuration. Browse a pre-loaded catalog, deploy an environment using the AI Designer, and experience the full Self-Service flow, from natural language prompt to running infrastructure.

Pre-loaded catalog with governed blueprints across dev, QA, ML, and demo environment types.

AI Environment Designer active in the sandbox. Describe what you need and watch the Copilot build it.

No credentials required to explore the full deployment flow, including policy enforcement and TTL management.

Live environment management to see the governance controls, cost tracking, and lifecycle management in action.

Ready to eliminate your platform engineering backlog?

See how Self-Service turns your governed infrastructure inventory into a catalog your entire organization can deploy from, in a live session tailored to your environment and team structure.