From Vibe Coding
to Production on AWS

That's exactly who this service is for. You never need to open the AWS Console after deployment. Your only action is git push — changes go live in 3–5 minutes automatically.

I leave you documentation written for developers, not DevOps engineers. AWS runs in the background. You keep shipping.

Everything needed for a production-ready standard project:

• AWS EC2 server + Docker Compose for your app
• PostgreSQL / MySQL / any database
• Custom domain + SSL (auto-renewing)
• GitHub Actions CI/CD via OIDC — keyless, no stored secrets
• Terraform blueprints saved in your GitHub repo
• Sentinel monitoring — hourly checks + billing alerts
• Cost & Security review from day one
• Architecture docs + deployment guide
• 1 week of infrastructure support

Standard ($497) — single server, single database, one app:

• Next.js, FastAPI, Laravel, Django, Node.js/Express
• PostgreSQL or MySQL as the primary database
• Single EC2 + Docker Compose setup
• Standard traffic (no auto-scaling needed)

Complex ($797–$997) — scoped after the initial conversation:

• Multiple services (backend + worker + scheduler + Redis)
• Live data migration from existing hosting
• High-load architecture requiring Auto Scaling or Multi-AZ RDS
• Custom VPC design or private networking requirements

For a prototype or MVP — use Vercel. It's faster to set up and perfectly fine for testing ideas.

AWS Vibe Deploy makes sense when:

• Your Vercel/Railway bill started growing and you're not sure why
• You need a real database without connection drop issues
• You want to own the infrastructure, not rent it indefinitely
• You need SSH access, custom configs, or full server control
• You're building something real and want predictable $5–30/mo costs

I deploy infrastructure — the server, database, domain, SSL, and CI/CD pipeline. If your app runs locally and connects to a database correctly, it will run on my setup.

What I don't fix: bugs in your application logic, missing environment variables you forgot to tell me about, or code that never worked locally.

What I do fix during the support week: anything infrastructure-related — connectivity, SSL issues, deployment failures, server configuration.

Here's the exact process for deploying Docker Compose to AWS EC2:

• Provision EC2 instance (t3.small or t3.medium) via Terraform
• Install Docker Engine + Docker Compose on the server
• Configure your docker-compose.yml for production (env vars, volumes, restart policies)
• Set up Nginx as reverse proxy with Let's Encrypt SSL
• Configure GitHub Actions to SSH-deploy or use Docker pull on push to main
• Set up S3 backups for database volumes (Standard plan+)

OIDC (OpenID Connect) is the secure, keyless way to connect GitHub Actions to AWS. Here's what happens on every deployment:

• GitHub Actions workflow starts and requests a JWT token from GitHub's OIDC provider
• AWS verifies the token against the trust policy we configured (scoped to your exact repo)
• AWS issues temporary credentials — valid for 1 hour only
• GitHub Actions uses those credentials to deploy, then they expire automatically

Yes — both App Router and Pages Router. The setup uses Next.js standalone output mode for optimal Docker performance:

• Add output: 'standalone' to your next.config.js
• Docker image uses the .next/standalone folder — minimal size
• Nginx handles SSL termination and proxies to Next.js on port 3000
• Static assets served via Nginx directly (no overhead on Node.js)
• Environment variables managed via .env on server or AWS Secrets Manager

Two approaches depending on your setup:

Option 1 — .env file on server (simpler, standard projects):

• You provide a list of variable names (not values) during setup
• I create a secure .env file on the EC2 server
• Docker Compose loads it via env_file: .env
• File is never committed to GitHub

Option 2 — AWS Secrets Manager (complex projects, higher security):

• Secrets stored encrypted in AWS
• App fetches them at startup via IAM role — no plaintext on disk

Standard setup (Docker Compose on EC2):

• PostgreSQL runs as a Docker container alongside your app
• Data persists via a named Docker volume (survives container restarts)
• Automated daily backups to S3 (Standard plan and above)
• Database accessible only from the app container — not exposed publicly

Complex setup (Amazon RDS — scoped separately from $797):

• Fully managed PostgreSQL with automated patching
• Multi-AZ for 99.95% uptime and automatic failover
• Point-in-time recovery up to 35 days back
• Best for high-traffic apps or compliance requirements

Every deployment includes:

• Your custom domain pointed to the EC2 server (A record in your DNS)
• Let's Encrypt SSL certificate — free, auto-renewing every 90 days
• Nginx configured for HTTPS-only (HTTP redirects to HTTPS)
• www → non-www redirect (or vice versa, your preference)

You need either access to your domain's DNS settings, or I can help you purchase a domain. Domain registration itself costs $10–15/year through a registrar — that's separate from the deployment fee.

Terraform is Infrastructure as Code — every AWS resource is defined in files, not clicked through a console. After deployment, your repo contains:

• main.tf — EC2 instance, security groups, networking
• variables.tf — configurable parameters (instance type, region, etc.)
• outputs.tf — server IP, domain, ARNs
• .github/workflows/deploy.yml — CI/CD pipeline
• docker-compose.yml — your app's container configuration
• nginx.conf — reverse proxy and SSL setup

The essentials:

• GitHub repository with your code (private is fine)
• Your tech stack — language, framework, database, any external services
• A domain name (or I can help you pick one)
• AWS account — free to create at aws.amazon.com, takes 5 minutes
• List of environment variable names your app needs (not values)

Still writing code? Fill the form anyway — we can plan the deployment now and execute when your code is ready.

Yes, for standard projects. The clock starts when I have everything I need: repo access confirmed, stack verified, domain ready.

Most standard deployments are done in 24–36 hours. 48 hours is the conservative promise.

It takes longer when:

• App has dependencies that only surface in production environment
• Domain DNS propagation is slow (beyond my control, up to 48h)
• Complex scope that wasn't fully described in the initial form

Mostly no. The process is async via Telegram. You'll need to:

• Run the one-time security setup script in AWS CloudShell (~5 minutes)
• Confirm environment variable values once (securely)
• Review and approve the working URL at the end

Everything else happens on my side. No calls required for standard projects.

Each order covers one application deployment. A second project is a new order at the same price.

Returning clients get priority turnaround — I already know your AWS setup, so subsequent deployments are typically faster.

Have multiple apps to deploy at once? Reach out before ordering — I can often arrange a package deal.

I access your account via a Switch Role — like a guest key, not a master key. You create it yourself by running a one-time script in AWS CloudShell (inside your own browser). I never see your password, root credentials, or access keys.

The role grants PowerUserAccess — enough to deploy infrastructure, but with zero access to your billing dashboard, payment methods, or account settings.

Many developers copy permanent AWS_ACCESS_KEY_ID and paste them into GitHub Secrets. If the repo is ever compromised — leaked, forked, or accessed by a bad actor — those keys are exposed permanently. Attackers use them for crypto mining and you get a $5,000 AWS bill.

With OIDC, GitHub Actions gets a short-lived token that expires in 1 hour. There are no permanent credentials in your repo. Even if someone gets the token — it's already expired by the time they try to use it.

One step. No calls. No emails. No waiting:

The moment you click Delete, the Switch Role is gone. Your app keeps running — only my access disappears. Your CI/CD pipeline continues working via the separate GitHub OIDC role.

• Your code — stays in your GitHub repo. I never copy it anywhere.
• Your data — lives in your AWS account, in the database I set up. You have full access. I don't have a copy.
• Your credentials — stored as encrypted environment variables on the server or in AWS Secrets Manager. In your account, not mine.
• After delivery — I have no persistent access to anything. Zero.

Typical monthly AWS cost for a standard deployment:

• EC2 t3.small — ~$15/mo
• EBS storage 30GB — ~$2.40/mo
• Elastic IP — ~$3.60/mo
• Data transfer (moderate traffic) — ~$1–5/mo

Total: ~$10–25/month for most apps at moderate traffic.

From me: No. You pay $497 once. No monthly fee, no retainer, no "maintenance subscription" unless you choose the Maintenance & Monitoring add-on.

From AWS: You pay AWS directly for what you use — server time, storage, data transfer. I configure billing alerts so nothing surprises you.

Optional extras: Domain registration (~$10–15/year from a registrar, not me). Complex project scope ($797–$997, discussed upfront). Maintenance & Monitoring ($99/month, optional).

This is the recurring option for clients who want zero infrastructure overhead long-term:

• Weekly Sentinel report — infrastructure health, AWS costs, anomalies, uptime stats
• OS + Docker patching — monthly security updates applied with zero downtime
• 24/7 uptime monitoring — Telegram alert if your app goes down, before your users notice
• Priority support — 2-hour response time for infrastructure issues
• Quarterly cost review — identify unused resources, optimize AWS spend

Before work starts — full refund, no questions.

Work in progress, issue on my side — I fix it or refund the relevant portion. I'm not interested in keeping money for work that didn't deliver.

Issue is in your code (app bugs, missing env vars, logic errors) — outside infrastructure scope, no refund. I'll still help you figure it out.

I'm a solo operator. My reputation is worth more than any single sale.

• Working URL with SSL — your app is live
• All Terraform code committed to your GitHub repo
• GitHub Actions workflow — push to main, deploy in 3–5 min
• Sentinel monitoring running with hourly checks
• Billing alerts configured — you know before AWS charges grow
• Architecture documentation — what was deployed and why
• Deployment guide — how to manage and update going forward
• 1 week of infrastructure support via Telegram

For code changes — just git push to your main branch. GitHub Actions deploys automatically in 3–5 minutes. Zero console interaction required.

For infrastructure changes (adding a service, changing server size) — the Terraform files in your repo are the source of truth. Any developer can modify them. Or you come back to me — returning clients get priority scheduling.

Vertical scaling (bigger server) — change one line in Terraform, apply. Takes 10 minutes, zero data loss. t3.small → t3.medium → t3.large as traffic grows.

Horizontal scaling (Auto Scaling + Load Balancer) — this is a complex project engagement. We scope it together, typically $797–$997 depending on architecture requirements.

Database scaling — if you outgrow the Docker PostgreSQL setup, migrating to Amazon RDS is straightforward with Terraform. Data migration takes 30–60 minutes of downtime or zero downtime with replication.

Three options:

• Maintenance & Monitoring ($99/mo) — priority 2-hour response, infrastructure issues handled for you
• One-time fix — reach out, I'll quote a small engagement for the specific issue
• Self-service — all your Terraform code is in your repo. Any DevOps engineer can diagnose and fix using the documentation I left