Customizing values

Configure and customize your applications using inputs and per-installation overrides

Inputs let you customize how an application deploys without modifying its underlying source. Akua provides a wizard-driven editor that lets you configure applications, manage changes, and control how updates roll out to installations.

For most customers, the dashboard’s wizard is all you need. For advanced edits — patching individual fields, adding sidecars, overriding what the schema doesn’t expose — see Customize an installation via git. Both surfaces edit the same underlying state: the wizard writes to your installation’s inputs.yaml, and a git push to that same repository is equivalent.

Understanding inputs

Inputs are YAML configuration that drive how an application is rendered for a specific installation. They control everything from resource allocations and scaling behavior to application-specific settings and networking configuration.

When you customize inputs, Akua:

• Writes the change to the installation’s inputs.yaml
• Re-renders the deployment manifests against the package’s composition logic
• Validates inputs against the package’s input schema when available
• Commits the new render to the installation’s package repository

The wizard and git push are two views over the same state. UI edits and git pushes converge on the same inputs.yaml.

Multi-source configuration

Many applications combine multiple package sources — for example, a web application with a database, cache, and monitoring stack. Akua’s editor provides a tabbed interface where you configure each source independently while applying all changes in a single transaction.

Using the multi-source editor

When editing inputs for products or installations with multiple sources:

1. Switch between sources using the tabs at the top of the editor
2. Edit each source independently in YAML or form view
3. Track modifications with visual indicators (orange dots) on tabs that have been changed
4. Apply all changes at once with the “Apply All” button

The editor shows:

• Modified badge - Count of sources with unsaved changes
• Source tabs - All sources displayed as switchable tabs
• YAML/Form toggle - Switch between raw YAML and guided form interface
• Diff highlighting - See exactly what differs from defaults

The form view provides a structured interface when the package exposes a JSON Schema. Use YAML view for advanced configurations or sources that don’t expose a schema.

Product inputs and install inputs

Akua distinguishes between product-level inputs (the package definition shared across installations) and install-level inputs (per-installation customization). Understanding this distinction is crucial for managing updates effectively.

Product inputs

Product inputs define the default configuration for all future installations. When you update product inputs:

1. Package definition updated - The new configuration becomes the default for new installs
2. Existing installs unchanged - Current deployments continue running on their current package
3. New installs use updated inputs - Future installations get the new defaults
4. Manual rollout required - You control when existing installs upgrade

Use product inputs when:

• Setting default configuration for all customers
• Preparing new features or settings
• Testing changes before wide rollout
• Managing staged deployments

Standalone install inputs

Standalone installations have their own package definition (1:1 relationship). When you update inputs for a standalone install:

1. inputs.yaml updated immediately - Changes are written to the installation’s repository
2. Re-rendered - The new configuration is rendered into the installation’s manifests/
3. Application redeploys automatically - The new configuration is applied to your cluster
4. Single installation affected - Only this specific install changes

Use standalone install inputs when:

• Configuring customer-specific installations
• Making one-off customizations
• Testing configurations for specific environments
• Managing independent deployments

Product-based install overrides

Product-based installations support per-install input overrides that layer on top of product defaults. When you customize inputs for a product-based install:

1. Overrides stored separately - Your customizations are saved as install-specific overrides
2. Product defaults preserved - The product’s package definition remains unchanged
3. Inputs merged automatically - Product defaults + install overrides are merged into inputs.yaml
4. Updates persist - Overrides survive product updates
5. Application redeploys - The new merged configuration is applied to your cluster

Use product-based install overrides when:

• Customizing installations for specific customers (custom domains, branding, resource limits)
• Enabling customer-specific features or toggles
• Adjusting configurations per environment (production vs staging)
• Maintaining customer settings across product updates

Install overrides always take precedence over product defaults. When you update the product, customer overrides are automatically merged with the new defaults, ensuring customizations persist.

Input layering and merging

Akua uses a layered approach to merge inputs from multiple sources, ensuring predictable and maintainable configurations.

Merge order

Inputs are merged in the following order (later layers override earlier ones):

1. Upstream defaults - Defaults defined in the package’s source
2. Product inputs - Defaults configured at the product level
3. Install overrides - Customer-specific overrides for product-based installs
4. Install metadata - System-generated values like the installation ID, which is available in your package’s composition logic via the install’s metadata context

Deep merging

Akua performs deep merging of nested objects:

# Product inputs
database:
  host: "prod-db.example.com"
  port: 5432
  ssl: true

# Install override
database:
  host: "customer-db.example.com"

# Final merged result
database:
  host: "customer-db.example.com"  # Overridden
  port: 5432                       # From product
  ssl: true                        # From product

Arrays are replaced entirely rather than merged:

# Product inputs
features:
  - "basic"
  - "standard"

# Install override
features:
  - "basic"
  - "premium"

# Final merged result
features:
  - "basic"      # Completely replaced
  - "premium"    # Not merged

When customizing inputs, you only need to specify the keys you want to override. All other product inputs are automatically included in the merged configuration.

Version management and rollouts

When you update product inputs, Akua records a new product version without affecting existing installations. This gives you precise control over when and how updates roll out to your customers.

The update workflow

Viewing available updates

Each product installation shows its current package version and whether updates are available:

• Current version badge - Shows the package version currently deployed
• Latest version badge - Shows the newest available version
• Update available indicator - Orange badge when install is behind latest

Rolling out to a single install

To update a specific installation:

1. Navigate to the product’s installations list
2. Click Update on the installation row
3. Review the change (current version → latest version)
4. Confirm the update

The installation updates to the latest package version immediately. Use this approach for:

• Testing updates with a pilot customer
• Staggered rollouts across customers
• Customer-requested upgrades
• Selective deployment strategies

Rolling out to all installs

To update all installations at once:

1. Navigate to the product details page
2. Click Update All Installs in the installations section
3. Review the update scope (shows count of installations)
4. Confirm the bulk update

All installations update to the latest package version simultaneously. Use this approach for:

• Security patches requiring immediate deployment
• Critical bug fixes
• Coordinated feature releases
• Simplified version management

Bulk updates execute in parallel but you can monitor each installation’s progress individually. Failed updates don’t block others from completing.

Editing inputs

For products

1. Navigate to your product details page
2. Click the Values button in the header
3. Configure each source using the tabbed interface:
   • Switch between sources using tabs
   • Edit in YAML or form view
   • Track changes with modification indicators
4. Click Apply All to save changes

This generates a new product version. Existing installations continue running the previous version until you choose to update them.

For product-based installations

1. Navigate to the installation details page (must not be the product owner)
2. Click the Values button in the header
3. Configure each source using the tabbed interface
   • You’ll see merged inputs (product defaults + any existing overrides)
   • Changes are stored as install-specific overrides
4. Click Apply All to save changes

This creates install overrides that layer on top of product defaults and triggers an immediate redeployment with the merged configuration.

Product owners cannot edit inputs for product-based installations directly (this would affect all customers). They must update the product instead. Only customers (non-owners) can create install-specific overrides.

For standalone installations

1. Navigate to the installation details page
2. Click the Values button in the header
3. Configure each source using the tabbed interface
4. Click Apply All to save changes

This updates the installation’s inputs.yaml and triggers an immediate redeployment with the new configuration.

Changes to standalone installations and product-based install overrides take effect immediately. Review configurations carefully before applying.

Status tracking

Akua provides real-time status indicators during input updates:

Status	Description
Saving…	Writing updated inputs to the installation repository
Packaging…	Rendering the new configuration into the installation’s manifests
Deploying…	Applying changes to your cluster (standalone installs only)

Progress appears on the Values button, allowing you to monitor the update without blocking other work.

Best practices

Version control strategy

• Update products first - Make package changes before rolling out to installs
• Test with single install - Verify configuration with one customer before bulk updates
• Use semantic versioning - Akua automatically versions packages; treat major updates carefully
• Document changes - Keep notes on what changed in each version

Multi-source configuration

• Configure all sources together - Use the multi-source editor to apply changes atomically
• Review modifications - Check the modified sources count before applying
• Validate YAML syntax - The editor warns about syntax errors before applying
• Use form view for structure - Form view prevents common YAML formatting mistakes

Rollout management

• Pilot test updates - Start with a single installation for new configurations
• Stagger large rollouts - Consider updating installations in batches for large products
• Monitor after updates - Check installation health after rolling out changes
• Keep previous versions - Don’t delete old package versions until all installs are migrated

Install overrides

• Minimize overrides - Only override inputs that truly need to be customer-specific
• Use product defaults - Set sensible defaults at the product level for common configurations
• Document overrides - Keep notes on why specific inputs were overridden for each customer
• Test product updates - Verify that product changes merge correctly with install overrides
• Review periodically - Check if overrides are still necessary as product defaults evolve

Security considerations

• Never commit secrets - Use environment variables and secret management for sensitive data
• Review inputs before applying - Especially when using form view which may expose all fields
• Limit who can update - Product inputs affect all customers; restrict access appropriately
• Audit changes - Every input change is a commit in the installation repository — use git history to track who changed what and when

Common scenarios

Increasing resource limits

Update CPU and memory limits to scale applications. For products, update the product inputs and roll out to installations that need more resources. For standalone installs, update inputs directly.

Enabling features

Many packages use feature flags in inputs. Enable features at the product level, generate a new version, then selectively update installations as customers opt in.

Environment-specific configuration

Use standalone installations for environment-specific deployments (dev, staging, production). Each can have different inputs while sharing the same base package.

Database connection strings

Update database URLs or connection parameters by editing inputs. For products, create a new version with updated defaults. For standalone installs, update directly to reconfigure immediately.

Scaling configuration

Adjust replica counts, autoscaling settings, and resource requests. Test with a single installation first, then roll out to others once validated.

Customer-specific customizations

Use per-install input overrides for product-based installations when customers need unique configurations. Navigate to the installation details page and edit inputs to create customer-specific overrides for custom domains, resource limits, feature toggles, or any other settings. These overrides layer on top of product defaults and persist across product updates, giving you the benefits of centralized product management while supporting customer-specific customizations.

Troubleshooting

Changes not applying

If input changes don’t take effect:

• Check syntax - Ensure YAML is valid with proper indentation
• Review status - Wait for “Packaging…” status to complete
• Verify rollout - For products, ensure you’ve updated the installations
• Check logs - View application logs for deployment errors in the installation details page

Schema validation errors

If the form view shows validation errors:

• Check required fields - Some inputs must be provided
• Verify data types - Ensure numbers, strings, and booleans match schema
• Switch to YAML - Use YAML view for complex configurations
• Consult package docs - Review the package’s documentation for input requirements

Installation not updating

If an installation doesn’t update after rollout:

• Review version - Verify the installation is pointing to the new package version
• Check status - Look for errors in the installation details page
• Check deployment - Ensure the application is deploying successfully

Related topics

Products

Create and manage products with configurable inputs.

Deployments

Deploy installations to your infrastructure.

Package generation

How Akua generates packages.

Package versioning

How commit history maps to deployments.