Browse and deploy from a curated library of service templates with the new discovery UI. Templates cover common service types: web servers, data stores, workers, and more. Each template comes with pre-configured settings, environment variables, port mappings, and sensible resource defaults.

How it works#

When adding a new service to the canvas, you can now browse templates by category instead of starting from a blank configuration. Select a template, customize the settings if needed, and deploy. Variable references between services are wired up automatically based on the template definition.

Templates are designed to get you from zero to deployed as fast as possible, especially for common patterns like "web server + database + cache" that most projects need.

When creating a new environment, you can now fork variables from an existing one. Instead of re-entering every variable from scratch, select a source environment and its variables will be carried over.

A review step shows exactly which variables will be copied before anything is applied, so you can adjust values (like swapping production URLs for staging ones) before confirming. This is especially useful when spinning up preview or staging environments that share most of their configuration with production.

Environment variable references are now checked for circular dependencies. If service A references a variable from service B, which references one from service A, you'll see a clear warning on the canvas before deploying. Circular edges are rendered with a distinct style so they're easy to spot.

Circular references cause infinite resolution loops at deploy time, which previously resulted in confusing deployment failures. Now these are caught before you deploy.

Services will now automatically rebuild and update when you `git push` to your repository.

What is Keel#

Keel is a Kubernetes operator that watches for new container image tags and triggers rolling updates automatically. It runs inside your cluster and listens for webhook notifications from container registries (Docker Hub, GitHub Container Registry, etc.).

When a new image tag is published, Keel receives the webhook, matches it against your deployment's image policy, and initiates a rolling update. No CI/CD pipeline changes needed.

How it works in Suga#

When you deploy a service through Suga, we configure Keel's image update policy for that deployment. Push a new tag to your registry, and Keel handles the rest: it detects the new tag, updates the deployment spec, and Kubernetes rolls out the new pods.

This is particularly useful for teams that build images in external CI systems (GitHub Actions, CircleCI, etc.) and want deployments to update automatically without triggering a full redeploy through the Suga dashboard.

Connect your GitHub repositories directly to Suga for source-linked builds.

How it works#

1. Connect: Click "Connect GitHub" in your project settings. A popup-based OAuth flow installs the Suga GitHub App on your account or organization.
2. Link a repo: In the build configuration for any service, select which GitHub repository to link.
3. Build: When you trigger a deployment, Suga pulls the source from your linked repo and builds the container image.
4. Trace: Each build shows the commit hash, author, and a direct link back to the source on GitHub, making it easy to trace what's deployed to the code that produced it.

Features#

• Popup-based OAuth flow (no redirect away from the dashboard)
• Per-build author attribution and commit links
• GitHub App permissions management from the settings page
• Works with both personal accounts and organizations

The dashboard now shows org-level resource limits and enforces CPU-to-memory ratios per tier. A banner in the changes panel warns you when you're approaching limits before you deploy.

• Minimum memory ratio enforcement to prevent misconfigured pods
• Validation messages match the enforced limits exactly
• Clear upgrade path when you hit the ceiling on your current tier

Suga now tracks infrastructure costs per service and supports a credit-based billing model. See what each service costs in terms of compute and storage, and apply credits to offset usage.

• Per-service cost breakdown on the billing page
• Credit balance and usage tracking
• Upgrade prompts when approaching tier limits
• Links to billing directly from deployment dialogs

You can now create and configure persistent volumes directly from the canvas via a dedicated dialog. The dialog validates mount paths and storage sizes before creation, and includes tooltips on delete actions to prevent accidental data loss.

You can now configure service autoscaling directly from the canvas. Set CPU and memory thresholds, and Suga handles the HPA configuration on your cluster.

• Per-service autoscaling rules
• CPU and memory target thresholds
• Replica limits enforced per tier
• Real-time replica count visible on the canvas node

When a threshold is exceeded, Suga scales the deployment up automatically. The canvas node updates in real-time to reflect the current replica count as pods come online.