AI coding tools like Lovable, Bolt.new, Cursor, and v0 have dramatically changed how fast you can go from idea to working app. What used to take weeks of boilerplate now takes hours.
But there's a gap that all of these tools leave open: getting your app to production.
Lovable can generate a full-stack Next.js application. Bolt.new can scaffold an entire API. But neither of them provisions a VPC on AWS, sets up an ECS Fargate service, creates an RDS database with automated backups, or wires a CI/CD pipeline to your GitHub repo.
This guide covers exactly how to bridge that gap.
What "production" actually means
When developers say an app is "in production," they mean it's running on infrastructure that is:
- Highly available — it doesn't go down when one server fails
- Scalable — it handles traffic spikes without manual intervention
- Secure — data is encrypted, network is isolated, secrets are managed properly
- Maintainable — you can deploy new versions without downtime, and roll back if something breaks
- Observable — you have logs, metrics, and alerts when things go wrong
A Vercel deployment of a Lovable app might tick some of these boxes. But for teams that need AWS specifically — for compliance, enterprise customers, or because the rest of their stack is AWS-native — Vercel isn't the answer.
The production infrastructure your Lovable app needs on AWS
Here's everything that needs to exist before your app is production-ready on AWS:
VPC and networking
A Virtual Private Cloud (VPC) is an isolated network environment in AWS. Your app's components — the ECS service, the RDS database, the Redis cache — all live inside this VPC. The database is in a private subnet (not accessible from the internet), while the load balancer is in a public subnet (internet-facing).
Setting this up manually involves: creating a VPC, configuring CIDR blocks, creating public and private subnets in multiple availability zones, setting up route tables, creating an internet gateway and NAT gateway, and configuring security groups.
ECS Fargate service
Your Lovable app needs to run as a Docker container. ECS Fargate is the AWS-managed container runtime — you provide the Docker image and resource requirements, and AWS runs the container without you managing any servers.
The ECS service maintains a desired number of running tasks (containers), replaces failed tasks automatically, and integrates with your load balancer for traffic routing.
Application Load Balancer + HTTPS
An ALB routes incoming HTTPS traffic to your ECS tasks. AWS Certificate Manager (ACM) provides a free SSL certificate that auto-renews. The ALB runs health checks against your containers and routes traffic away from unhealthy tasks.
RDS PostgreSQL
If your Lovable app uses a database (most do), you need AWS RDS rather than a hosted Postgres add-on. RDS gives you automated daily backups, point-in-time recovery, Multi-AZ failover, and read replicas — all critical for production data.
CI/CD pipeline
Every time you push code to GitHub, you need it to automatically build, push to ECR, and deploy to ECS with zero downtime. This requires a GitHub Actions workflow (or CodePipeline) that handles the full deploy lifecycle.
Step-by-step: Lovable to production AWS with NoahOps
Let's walk through the actual steps.
Step 1: Export your Lovable app to GitHub
In Lovable, click the GitHub button and export your project to a new repository. Lovable generates standard Next.js or React code that works out of the box.
If your app doesn't have a Dockerfile, that's fine — NoahOps can detect common frameworks and build them automatically. Or you can ask Lovable to generate a Dockerfile for you.
Time: 2 minutes
Step 2: Sign up for NoahOps and connect your AWS account
Create a NoahOps account and run through the AWS connection wizard. You'll create an IAM role in your AWS account that gives NoahOps the permissions it needs to provision infrastructure. This uses AWS's cross-account role mechanism — no long-lived credentials are stored anywhere.
Time: 5 minutes
Step 3: Connect your GitHub repo
In NoahOps, connect your GitHub account via OAuth and select the repo your Lovable app lives in. NoahOps detects your framework and build configuration.
Time: 2 minutes
Step 4: Configure your environment
Set up your production environment in the NoahOps UI:
- Service type: Web (ECS Fargate + ALB)
- Database: RDS PostgreSQL (choose instance size)
- Environment variables: Add any API keys or config your app needs
- Custom domain: Enter your domain — NoahOps handles the ALB + ACM setup
If you used Supabase or a built-in Lovable database, you'll migrate the data later (or start fresh if it's a new deployment).
Time: 5 minutes
Step 5: Deploy
Click deploy. NoahOps provisions the full stack:
- VPC with public/private subnets (30s)
- RDS PostgreSQL instance (3–5 min)
- ECS cluster and task definition (1 min)
- ECS Fargate service with desired task count (1 min)
- ALB with HTTPS and health checks (2 min)
- GitHub Actions CI/CD pipeline (1 min)
Total: ~12 minutes. You get a live HTTPS URL at your custom domain. Every future git push deploys automatically.
Time: 12 minutes
Using Noah AI instead of the UI
If you'd rather skip the configuration wizard entirely, you can describe what you want to Noah AI in plain English:
"Deploy my Next.js app from github.com/me/my-app to production on AWS with a Postgres database and Redis cache. I need staging and production environments."
Noah maps this to a complete infrastructure plan, shows you what will be created, and provisions it on approval.
This is especially useful for vibe coders who aren't familiar with AWS terminology — you don't need to know what an ECS task definition is to tell Noah what you want.
What about Supabase / Lovable's built-in database?
If your Lovable app uses Supabase for its database, you have two options:
Option A: Keep using Supabase. Your ECS service can connect to Supabase from AWS — just set the DATABASE_URL environment variable in NoahOps. This is the fastest path.
Option B: Migrate to RDS. For production workloads where you want everything in your own AWS account (compliance, data residency, cost control), migrate the data:
# Export from Supabase
pg_dump -h db.supabase.co -U postgres -d postgres > backup.sql
# Import to RDS (NoahOps gives you the endpoint)
psql -h your-rds-endpoint.rds.amazonaws.com -U postgres -d your_db < backup.sql
NoahOps injects DATABASE_URL into your ECS tasks automatically — you don't need to change your application code.
Common questions
Do I need to know Terraform? No. NoahOps abstracts all infrastructure provisioning. You interact through the UI or Noah AI.
What if my Lovable app uses Bolt.new, Cursor, or v0 instead? Same process. Any app in a GitHub repo — regardless of how it was built — can be deployed via NoahOps.
How much does it cost to run my app on AWS? A basic setup (ECS Fargate 0.5 vCPU + RDS db.t3.micro) costs roughly $30–50/month in AWS infrastructure costs. NoahOps itself starts free (Starter plan: 1 environment, 1 service).
What happens when I push new code? GitHub Actions runs automatically: builds your Docker image, pushes to ECR, and triggers a rolling ECS deployment. Your app updates with zero downtime.
The bottom line
Building apps with AI coding tools has never been faster. The infrastructure gap — getting those apps to production — has historically been the hard part.
NoahOps closes that gap. You don't need a DevOps engineer, you don't need to learn Terraform, and you don't need to spend a week configuring AWS manually. Connect your repo, describe what you need, and ship.