Connect a GitHub repo. AutoDeploy reads your actual stack, generates the Dockerfile, CI/CD, Kubernetes, and Terraform your team needs, and opens a PR you can review — or hands the whole pipeline off and deploys it for you.
No credit card. No YAML to write first. Real infra, generated from your real repo.
Reads your real dependency graph — package.json, requirements.txt, go.mod, and beyond — instead of guessing from a folder name.
Get started →Seven independent services, each with its own database, talking over short-lived signed tokens. Your session token never once reaches an internal service.
Get started →Every stored credential and SSH key is sealed with AES-256-GCM. Nothing sensitive is ever logged or returned in plaintext after it's written.
Get started →Every account gets an organization automatically. Invite teammates, assign OWNER, ADMIN, or MEMBER, and scope everything to the org — not a person.
Get started →Watch detection, generation, and deploy happen live. No refresh button, no guessing whether a build is still running.
Get started →Trigger runs and receive signed webhooks programmatically — build AutoDeploy into your own tooling instead of clicking through ours.
Get started →Every item below is a real, working generator or check in the product today — not a roadmap slide.
Authorize a repo with one click through your GitHub App installation. No server to provision, no YAML to write yet.
We read the actual dependency graph and framework signals in your repo — not a guess from the folder name — to identify your real stack.
Pick the artifacts you want. Get back a reviewable pull request with a working Dockerfile, CI/CD pipeline, Kubernetes manifests, or Terraform.
Merge it yourself and own the pipeline, or let AutoDeploy run the deploy end to end and watch it happen in real time.
This is the real dashboard UI, shown with sample data — its own design system, unchanged. Sign in and it's your repos, your runs, your deploys.
AutoDeploy was built as independent services from day one specifically so a compromise in one place can't cascade into everything else. Here's what that actually means underneath.
Every stored secret and SSH key is encrypted before it ever touches disk — not obfuscated, not base64, actually encrypted.
User sessions are RS256-signed and verified independently by every service. Internal calls use separate 30-second HS256 tokens minted fresh per request — a stolen session token can't be replayed against internal services.
Magic-link and verification tokens are SHA-256 hashed at rest and single-use. Even a database leak wouldn't hand over a working credential.
Every authentication endpoint is rate-limited against brute force and abuse — tightest on the routes that can trigger an email send.
AutoDeploy exists because generating a Dockerfile, a CI pipeline, and a Kubernetes manifest for the same repo shouldn't mean three separate afternoons of copy-pasting from old projects. We built the tool we wanted — one that reads your actual code, generates real infrastructure, and gets out of your way.
Whether you're shipping your first side project or your tenth microservice this quarter, AutoDeploy gives you the same starting point a senior DevOps engineer would — in seconds, not a sprint.
Complex DevOps decisions made simple — pick your artifacts, review the output, ship it.
Every generator is exercised by real tests against real repos, not hand-waved.
Nothing is rented. Every file we generate is yours — commit it, edit it, delete us from the picture entirely.
If a feature isn't real yet, the product says so instead of pretending. No fake capability, anywhere.
Every action in the dashboard — listing repos, triggering a generation run, checking a deployment — is backed by a public, key-authenticated REST API with outbound webhooks for the events you care about. Script it, wire it into your own tooling, or just read the spec.
Read the API reference →$ curl -H "Authorization: Bearer ad_live_..." \
https://autodeploy.smilekisan.com/v1/repositories
{
"installations": [{
"accountLogin": "your-org",
"repositories": [
{ "fullName": "your-org/checkout-api" },
{ "fullName": "your-org/worker-payments" }
]
}]
}
$ curl -X POST \
-H "Authorization: Bearer ad_live_..." \
-d '{"artifactTypes":["dockerfile"]}' \
https://autodeploy.smilekisan.com/v1/repositories/:id/generate
{ "runId": "run_9f2a1c" }A CI pipeline that generates config, or an edge network you never touch a server on — both are real products, and neither one can do what happens when you actually own the infrastructure underneath.
One click boots a real EC2 instance under a scoped IAM role — clones your repo, builds it, starts it running. The same thing you'd do by hand in the AWS Console, just done for you. Not a black box you rent by the request; a real server you own and could SSH into tomorrow.
Netlify and Vercel can't offer this — their whole pitch is that you never touch a server at all.
Real spend, broken down by service and region, pulled live from your own account's Cost Explorer — not a flat number a platform bills you and hopes you never ask about.
A platform that hosts your app for you has no incentive to show you this — they're the ones setting the number.
Every generator gives you a Dockerfile or a CI config to download. This one goes further — click Run plan and watch the real terraform plan output against your own AWS account, not a preview or a guess.
GitLab and GitHub Actions can generate the same file — neither one executes it for you.
No edge network to buy into, no vendor lock-in — connect a server you already have or your own AWS account, and get push-to-deploy simplicity anyway.
Connect a repo, get a working Dockerfile and CI, deploy it once.
For teams running real infrastructure, not renting someone else's.
For organizations who need to see and control every server and dollar.
Plan limits are enforced live, not just on this page — Pro and Team checkout run through Stripe.
Connect a real GitHub repo and watch detection, generation, and deploy happen live — no sales call, no credit card.