Skip to main content

Frequently Asked Questions

Getting Started​

Why should I use Torque if I can manage my application deployments directly on the cloud or through my CI/CD tool?​

While you can manage deployments directly, Torque provides significant advantages across multiple dimensions. Here are the key factors that make Torque a valuable addition to your infrastructure toolkit:

Core Capabilities:

  • Lifecycle Management: Complete environment lifecycle management from provisioning to decommissioning, including automated scheduling, renewal policies, and graceful shutdown procedures that ensure nothing is left behind on the cloud. Learn more about scheduled environments and environment management.

  • IaC Orchestration: Torque provides sophisticated Infrastructure as Code orchestration that goes beyond basic deployment, managing complex dependencies and multi-technology stacks with ease across different cloud providers and tools. Explore our blueprint designer guide and multi-technology orchestration examples.

  • Governance: Unified security and policy management that protects your admin credentials within Torque agents, enables team collaboration through spaces, and enforces organizational standards and compliance requirements automatically across all deployments. Read about policies, roles and permissions, and Torque agents.

Additional Capabilities:

  • Cost Management: Automatic cleanup of cloud resources when environments are no longer needed, plus comprehensive cost tracking with detailed analytics and forecasting. Torque attaches tags to every cloud resource for powerful monitoring and cost optimization. Learn more about cost tracking and cloud efficiency reports.

  • Day 2 Automation with Context: Unlike simple CI/CD pipelines, Torque understands the full context of your environments and automates ongoing operations like scaling, updates, and maintenance with full awareness of your infrastructure state. Explore actions and workflows and drift detection.

  • Discovery and Curation: Native capability to scan existing cloud environments and generate Infrastructure as Code representations of current resources, allowing you to bring brownfield infrastructure under management and standardize your deployments. Get started with discovering your assets and importing cloud resources.

  • Usage Visibility: Comprehensive visibility into resource usage, costs, and environment health with detailed analytics and reporting that help optimize your infrastructure spend and performance. View reports overview and activity and adoption reports.

  • Lower Error Rate → Higher Adoption: By providing standardized, tested deployment patterns and automated validation, Torque significantly reduces deployment errors, leading to higher developer confidence and faster adoption of infrastructure automation practices. See our blueprint quickstart guide and getting started guides.

Deployment and Security​

Where are the applications deployed?​

For security and performance reasons, we designed Torque to deploy applications on Kubernetes (EKS on AWS EC2 and AKS on Azure). Support for additional cloud providers is currently in development and will be released soon.

Can I automate the deployment of Torque blueprints through a CI/CD process?​

Absolutely! Torque supports integration with some of the leading CI/CD tools out there, including:

  • GitHub Actions
  • Azure DevOps
  • GitLab CI
  • Jenkins
  • CloudBees
  • TeamCity
  • CircleCI
  • Bamboo
  • And more

Click here and follow our documentation to set up your pipelines and start seeing value.

How do you protect my access credentials?​

It's no secret that working with the cloud requires the use of very powerful admin credentials, which can cause some serious damage if they fall in the wrong hands. In Torque, your admin credentials are safely tucked away in the system, within what we call Torque agents, which allow Torque to access and use the Kubernetes cluster on the cloud.

The blueprints reference the agents but otherwise cannot access the credentials. Same goes for the end-user and CI/CD tool - the end-users who launch the environments don't have access to the actual Azure keys from the token.

Learn more about Torque agents, service accounts for AWS, service accounts for Azure, and advanced security settings.

Environment Management​

What happens when I no longer need the environment?​

Torque environments have a duration period, which automatically ends the environment, deleting all the environment's cloud artifacts from the cluster. In addition, Torque allows you to manually end the environment at any time directly from the Torque application. The bottom line is that nothing from the environment is left on the cloud.

Learn more about scheduled environments and environment lifecycle management.

Can I limit the duration of environments?​

Of course! The blueprint designer reserves the right to set a duration policy, per blueprint, which sets the maximum duration for that particular blueprint. So you can limit the blueprint to a certain time frame, which is especially useful for high-cost blueprints, or let it run indefinitely for environments that need to be online at all times.

See our guide on policies and blueprint configuration.

Scaling and Performance​

What scale can Torque support in production environments?​

Torque's elastic architecture has been proven to handle enterprise-scale workloads across multiple dimensions in production:

User Scale:

  • Multi-tenant SaaS: Supports hundreds of thousands of users across the platform
  • Enterprise Organizations: Large customers managing thousands of developers and infrastructure teams
  • Concurrent Operations: Real-world deployments handling 7,000+ concurrent environments weekly

Infrastructure Scale:

  • Resource Management: Platform manages 100+ million cloud resources in production
  • Environment Volume: 10+ million environments created and managed
  • Multi-Cloud Footprint: Spans AWS, Azure, GCP, and hybrid cloud deployments at massive scale

Performance in Production:

  • Concurrent Environments: Enterprise customers routinely run 7,000 concurrent environments per week
  • Resource Density: Each environment averages 2-5 compute resources, demonstrating efficient resource orchestration
  • Horizontal Scaling: Linear scaling based on Kubernetes cluster capacity with no architectural bottlenecks

Technical Scalability:

  • No Concurrency Limits: Unlike traditional tools, there are no hard limits on concurrent operations within licensing boundaries
  • Self-Hosted Runners: Zero additional costs for increased concurrency due to customer-controlled runner infrastructure
  • Stateless Design: Enables unlimited horizontal scaling of execution capacity

Enterprise-Grade Operations:

  • Multi-Tenant Isolation: Secure space-based segregation supporting large organizational structures
  • API-First Integration: Handles machine-to-machine operations at enterprise scale
  • Governance at Scale: Policy enforcement and compliance across thousands of environments and users

The platform's proven track record demonstrates it can support organizations of any size, from small teams to Fortune 500 enterprises managing complex, multi-cloud environments with millions of resources and thousands of concurrent operations.

How does Torque efficiently handle external service integrations at scale?​

Torque's architecture is designed to minimize stress on external services while maintaining high performance through intelligent resource management:

Git Repository Management:

  • Intelligent Caching: Local repository caching reduces Git server load and improves blueprint retrieval performance
  • Incremental Updates: Only fetches changes since last sync, minimizing bandwidth and repository server impact
  • Connection Pooling: Reuses Git connections across multiple operations to reduce authentication overhead

Cloud API Optimization:

  • API Rate Limiting: Built-in rate limiting and backoff strategies prevent overwhelming cloud provider APIs
  • Batch Operations: Groups multiple API calls where possible to reduce total request volume
  • Regional Distribution: Leverages regional endpoints to minimize latency and distribute load
  • Intelligent Retry Logic: Exponential backoff with jitter prevents API thundering herd scenarios
  • Resource State Caching: Maintains local state cache to reduce unnecessary API polling

Database Efficiency:

  • Connection Management: Sophisticated connection pooling prevents database connection exhaustion
  • Query Optimization: Efficient queries and indexing strategies minimize database load
  • Read Replicas: Distributes read operations across multiple database replicas for high availability
  • Bulk Operations: Batch database operations where possible to improve throughput
  • Asynchronous Processing: Non-blocking database operations prevent performance bottlenecks

Cost-Effective Resource Management:

  • Elastic Scaling: Resources scale based on demand, preventing over-provisioning during low usage periods
  • Resource Sharing: Multiple operations share infrastructure resources efficiently
  • Cleanup Automation: Automatic cleanup of temporary resources prevents cost accumulation
  • Monitoring and Alerts: Proactive monitoring ensures optimal resource utilization and cost management

This approach ensures that even at enterprise scale with thousands of concurrent operations, Torque maintains excellent performance while being a good citizen to external services and keeping operational costs predictable and manageable.

How does Torque handle scaling and concurrency beyond limits of traditional tools like Terraform Cloud?​

Torque is highly elastic and scalable through the use of runners. Runners are pods (when running on Kubernetes) that handle the execution and life-cycle of Terraform runs. The scalability depends on several factors such as:

  • Cluster capacity
  • Runner configuration (stateless vs stateful)
  • Executor type (docker, kubernetes, etc.)

Torque can scale to hundreds of concurrent jobs, and can be configured to handle thousands of concurrent jobs. There are no additional costs associated with increased concurrency, as Torque runners are self-hosted. The native concurrency of Terraform is limited to a single operation per workspace, but Torque can manage multiple workspaces concurrently.

How does Torque prevent job queuing under heavy load?​

Torque's architecture is designed to prevent job queuing under heavy load by:

  • Distributing jobs across multiple runners
  • Using a queue system to manage job execution

There is no hard limit for the level of concurrency while using the platform, as long as you stay within the boundaries of the licensing capacity and model.

Flexibility and Control​

How can platform engineering teams extend Torque with custom solutions?​

Torque is designed to be highly flexible and extensible. It allows platform engineering teams to create Blueprints and Workflows, which are reusable modules (Building Blocks) that can encapsulate best practices and "golden paths". These Blueprints can be shared and versioned, allowing teams to evolve their infrastructure over time.

Learn more about blueprint design and workflows.

Does Torque offer API-first integration capabilities?​

Yes! Torque offers a robust API-first approach, allowing for seamless integration with other tools and systems. This is critical for machine-to-machine interaction and building future integration layers.

Brownfield & Day 2 Operations​

Can Torque discover and generate IaC code from existing cloud resources?​

Yes. This is natively supported through Torque's Curate feature. Curate can scan existing cloud environments and generate Terraform code that represents the current state of the resources.

Currently, the generated code is in Terraform format. While there is no native support for converting it to Kubernetes-native formats like Crossplane, the generated Terraform code can be used as a starting point for further customization.

Torque also supports native Kubernetes resources through its Helm and Kubernetes grains/runners.

Get started with discovering your assets and importing cloud resources.

How does Torque handle continuous reconciliation and drift detection?​

Torque periodically checks the state of the resources against the desired state defined in the Terraform code. Continuous reconciliation is handled through Torque's Drift Detection feature and is executed using Torque's runners. This allows the platform to automatically detect and correct configuration drift in live environments.

Learn more about drift detection and updates and Day 2 operations.

Does Torque support Kubernetes Resources?​

Yes. Torque supports Kubernetes resources through its Helm and Kubernetes grains/runners. The platform can act as a control plane for Kubernetes resources, allowing users to manage and provision these resources through the Torque interface. This enables integration with Custom Resources and supports Kubernetes-native platform engineering experiences.

See our Kubernetes getting started guide and Kubernetes as a Service example.