Skip to content

How it works

From GitHub to your customer's AWS in four steps.

You prepare a release once. Each customer approves access in their own AWS account, and Deployz deploys and updates it there.
Get Started Free
Steps 1 and 2: you connect GitHub, fix anything the readiness report flags, and build a release. Step 3: you send your customer an installation link; they review the Region, resources, and cost, then connect their AWS account. Step 4: Deployz deploys the release in their account and shows each step until it is live.

Step 1

Connect GitHub and analyze your repo

Deployz reads your repository with read-only access and reports what your app needs.

AI for understanding. Guardrails for deploying.

AI does not write your infrastructure, and it does not guarantee that your app is correct or secure.

Checks first
Rule-based detectors read your Dockerfile, package files, and configuration: runtime, port, health check, environment variables, database, cache, storage, and workers.
AI for open questions
When the checks leave a question open, such as an unclear start command, AI reads a few relevant files. Values that look like secrets are redacted first.
Strict limits on AI
AI answers must match a strict schema and only fill gaps. They never replace a value the checks found, and lower-confidence answers stay suggestions.
Clear labels
Each detected value shows its source. AI values are marked “Inferred by AI analysis — verify before relying on it.”
Your review
You check what Deployz detected, enter the values it needs, and override anything before you build a release.
Rule-based deployment
Deployz's own compiler turns the configuration into CloudFormation. It can create only supported AWS resources, in a fixed size profile. Preflight checks use no AI.
Deployz analysis runs deterministic checks on your repository first. AI helps only with questions the checks leave open, and Deployz labels those values as inferred by AI. You review what Deployz detected and enter the values it needs. Deployz then compiles the reviewed configuration into CloudFormation with its own rule-based compiler, which can create only supported AWS resources.

Step 2

Configure and build a release

Review what Deployz detected, fill in what the report asks for, and fix any blockers. Then build a versioned release from a commit.

  • Passed

    Checks your app already meets.

  • Needs input

    Values you must provide, such as environment variables.

  • Blockers

    Changes your app needs before it can deploy.

The report is advisory and can miss behavior in your code. For a blocker, Deployz can write fix instructions for your own coding tool; it never changes your repository. You can also run one free test deployment in your own AWS account.

Step 3

Your customer connects AWS

Send each customer an installation link. They do not need a Deployz account. Customers can install only while your subscription is active.

How AWS access works
  1. 1

    Open the installation link

    They see the resources, an AWS cost estimate, and every IAM action requested.

  2. 2

    Launch the connector

    They create it as a CloudFormation stack in their own AWS console.

  3. 3

    Deployz deploys the release

    The app and its resources are created in the customer's account.

Step 4

Deploy and manage updates

Deployz's rule-based compiler creates the supported AWS infrastructure. Deployz then deploys the release and marks the environment ready when its health check passes.

  • Releases

    Each customer runs the release you select.

  • Status

    See the progress and health of every customer environment.

  • Updates and rollbacks

    You start each update. If the new version fails its health check, the previous one keeps running. A rollback does not reverse database migrations.

  • Removal

    Remove a deployment, then delete its retained data as a separate step.

What Deployz creates in customer AWS

Only the parts your app needs, from one supported architecture. Your customer owns every resource.
The customer's AWS account. At the edge: an HTTPS certificate from AWS Certificate Manager and an Application Load Balancer. Inside a new, dedicated VPC: the web service and optional workers on ECS Fargate, an RDS database, and an ElastiCache cache. At the account level: an S3 bucket and AWS Secrets Manager. Deployz creates only the parts your app needs.
Web or API service
Amazon ECS on Fargate, behind an Application Load Balancer
Background workers
Separate ECS services from the same image
Database
Amazon RDS for PostgreSQL 16 or MySQL 8.0
Cache
Amazon ElastiCache (Valkey, Redis-compatible)
File storage
Amazon S3 bucket
Secrets
AWS Secrets Manager in the customer account
Network
A new, dedicated VPC
HTTPS
AWS Certificate Manager, for the default URL or a custom domain

Will Deployz work with my app?

Deployz supports one application architecture on AWS. Some apps need code changes first.

Technical requirements

Supported

  • One Linux x86-64 container image, built from your Dockerfile
  • A web or API service with an HTTP health check
  • Optional background workers from the same image
  • Optional PostgreSQL 16 or MySQL 8.0
  • Optional Redis-compatible cache
  • S3 file storage
  • HTTPS, with an optional custom domain
  • A new, dedicated network in the customer AWS account

Not supported

  • Services that need separate images
  • Databases other than PostgreSQL and MySQL
  • Message brokers such as Kafka or RabbitMQ
  • Existing customer VPCs
  • Other clouds or on-premises
  • Kubernetes or serverless apps
  • GPU workloads or ARM64 images
  • Attachable disk volumes

See what Deployz finds in your app.

Connect GitHub for a free readiness report.

Get Started Free