Skip to main content

Frequently Asked Questions

Getting Started​

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

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

Core Capabilities:

  • Lifecycle Management: Complete deployment 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 deployments and deployment management.

  • IaC Orchestration: Stack Automation 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 Stack Automation Management Servers, enables team collaboration through spaces, and enforces organizational standards and compliance requirements automatically across all deployments. Read about policies, roles and permissions, and Stack Automation Management Servers.

Additional Capabilities:

  • Cost Management: Automatic cleanup of cloud resources when deployments are no longer needed, plus comprehensive cost tracking with detailed analytics and forecasting. Stack Automation 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, Stack Automation understands the full context of your deployments 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 deployments 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 deployment 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, Stack Automation significantly reduces deployment errors, leading to higher developer confidence and faster adoption of infrastructure automation practices. See our blueprint quickstart guide .

Deployment and Security​

Where are the applications deployed?​

For security and performance reasons, we designed Stack Automation 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 Stack Automation blueprints through a CI/CD process?​

Absolutely! Stack Automation 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 Stack Automation, your admin credentials are safely tucked away in the system, within what we call Stack Automation Management Servers, which allow Stack Automation to access and use the Kubernetes cluster on the cloud.

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

Learn more about Stack Automation Management Servers, service accounts for AWS, service accounts for Azure, and advanced security settings.

Deployment Management​

What happens when I no longer need the deployment?​

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

Learn more about scheduled deployments and deployment lifecycle management.

Can I limit the duration of deployments?​

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 deployments that need to be online at all times.

See our guide on policies and blueprint configuration.

Scaling and Performance​

What scale can Stack Automation support in production deployments?​

Stack Automation'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 deployments weekly

Infrastructure Scale:

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

Performance in Production:

  • Concurrent Deployment: Enterprise customers routinely run 7,000 concurrent deployments per week
  • Resource Density: Each deployment 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 deployments 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 deployments with millions of resources and thousands of concurrent operations.

How does Stack Automation efficiently handle external service integrations at scale?​

Stack Automation'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, Stack Automation maintains excellent performance while being a good citizen to external services and keeping operational costs predictable and manageable.

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

Stack Automation 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.)

Stack Automation 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 Stack Automation runners are self-hosted. The native concurrency of Terraform is limited to a single operation per workspace, but Stack Automation can manage multiple workspaces concurrently.

How does Stack Automation prevent job queuing under heavy load?​

Stack Automation'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 Stack Automation with custom solutions?​

Stack Automation 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 Stack Automation offer API-first integration capabilities?​

Yes! Stack Automation 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 Stack Automation discover and generate IaC code from existing cloud resources?​

Yes. This is natively supported through Stack Automation's Curate feature. Curate can scan existing cloud deployments 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.

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

Get started with discovering your assets and importing cloud resources.

How does Stack Automation handle continuous reconciliation and drift detection?​

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

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

Does Stack Automation support Kubernetes Resources?​

Yes. Stack Automation 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 Stack Automation interface. This enables integration with Custom Resources and supports Kubernetes-native platform engineering experiences.