---
# === IDENTITY ===
id: software/mvp-development/deployment-devops-for-mvps/2026
canonical_question: "How do I deploy MVPs — Vercel, Railway, Fly.io, AWS Amplify with CI/CD, env management, monitoring, cost benchmarks?"
aliases:
  - "Best deployment platform for MVP startups"
  - "How to set up CI/CD for a startup MVP on Vercel or Railway"
  - "MVP hosting comparison Vercel vs Railway vs Fly.io vs AWS Amplify"
  - "Cheapest way to deploy a full-stack MVP with CI/CD"
entity_type: execution_recipe
domain: software > mvp-development > deployment devops for mvps
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === VERIFICATION ===
last_verified: 2026-03-12
confidence: 0.90
version: 1.0
first_published: 2026-03-12

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: evolving
  last_breaking_change: "Railway removed free tier in 2024; Fly.io eliminated general free tier for new orgs in 2024; Vercel restructured usage-based pricing in 2025"
  next_review: 2026-09-08
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Vercel Hobby plan is restricted to personal, non-commercial use — commercial MVPs require Pro at $20/user/mo"
  - "Railway Hobby plan: $5/mo base + usage, with $5 monthly resource credit — no free tier since 2024"
  - "Fly.io no longer offers a general free tier for new organizations — budget minimum ~$5/mo for basic usage"
  - "AWS Amplify free tier: 5 GB stored, 1 GB served, 1000 build minutes/mo — new accounts get $200 AWS credits for 6 months"
  - "Environment variables containing secrets must never be committed to Git — use platform-native secret management"
  - "Do not deploy to production until health checks pass and SSL is verified on custom domain"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs to choose a tech stack, not deploy one"
    use_instead: "Search knowledgelib.io for MVP tech stack selection — no dedicated unit yet"
  - condition: "User is deploying a static landing page, not a full-stack MVP"
    use_instead: "software/landing-pages/landing-page-platform-deployment/2026"
  - condition: "User needs Kubernetes or multi-region enterprise infrastructure"
    use_instead: "software/devops/k8s-deployment-service-ingress/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: tool_preference
    question: "Which deployment platform should be used?"
    type: choice
    options: ["Vercel", "Railway", "Fly.io", "AWS Amplify", "Render", "no preference — auto-select"]
  - key: technical_skill
    question: "What is the user's technical skill level?"
    type: choice
    options: ["semi-technical (can edit code)", "developer (can write code)", "DevOps experienced"]
  - key: budget_for_tools
    question: "What's the monthly infrastructure budget?"
    type: choice
    options: ["free tier only", "up to $20/month", "up to $50/month", "up to $200/month", "no limit"]
  - key: stack_type
    question: "What type of application is being deployed?"
    type: choice
    options: ["frontend only (Next.js/React/Astro)", "full-stack (frontend + API + database)", "API/backend only", "monorepo with multiple services"]

# === EXECUTION METADATA ===
execution:
  required_inputs:
    - name: "Application codebase in Git repository"
      source: "developer/mvp development phase"
      format: "GitHub or GitLab repository"
    - name: "Environment variables and secrets"
      source: "developer/third-party service dashboards"
      format: "key-value pairs (.env file format)"
  outputs:
    - name: "Deployed MVP application"
      format: "live URL with custom domain"
      description: "Publicly accessible application with SSL, CI/CD pipeline, environment management, and basic monitoring"
    - name: "CI/CD pipeline configuration"
      format: "platform-native config or GitHub Actions YAML"
      description: "Automated build-test-deploy pipeline triggered on Git push"
    - name: "Monitoring and alerting setup"
      format: "configured dashboard"
      description: "Basic uptime monitoring, error tracking, and performance metrics"
  tools_required:
    - name: "Deployment platform"
      purpose: "Host and serve the MVP application globally"
      tier: "free or paid"
      cost: "$0 (free tier) to $50/mo (startup scale)"
      alternatives: ["Vercel", "Railway", "Fly.io", "AWS Amplify", "Render"]
    - name: "GitHub or GitLab"
      purpose: "Source control and CI/CD trigger"
      tier: "free"
      cost: "$0 (free tier covers most startup needs)"
      alternatives: ["GitHub", "GitLab", "Bitbucket"]
    - name: "Error tracking service"
      purpose: "Capture and alert on runtime errors"
      tier: "free"
      cost: "$0 (Sentry free: 5K errors/mo) to $26/mo (Sentry Team)"
      alternatives: ["Sentry", "LogRocket", "Highlight.io", "Bugsnag"]
    - name: "Uptime monitoring"
      purpose: "Alert when the application goes down"
      tier: "free"
      cost: "$0 (BetterUptime free: 10 monitors) to $20/mo"
      alternatives: ["BetterStack", "UptimeRobot", "Checkly"]
  credentials_needed:
    - service: "Deployment platform"
      type: "OAuth (GitHub) or API token"
      where_to_get: "https://vercel.com/signup or https://railway.com or https://fly.io/app/sign-up"
      free_tier_limits: "Vercel: 100 GB bandwidth, Hobby only; Railway: $5 credit/mo; Fly.io: usage-based, no free tier"
    - service: "Sentry (error tracking)"
      type: "DSN string (API key)"
      where_to_get: "https://sentry.io/signup/"
      free_tier_limits: "5,000 errors/mo, 1 user, 30-day retention"
  estimated_duration: "30-90 minutes for initial deployment + CI/CD + monitoring"
  estimated_cost: "$0 (free tiers) to $50/mo (startup production)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/software/mvp-development/deployment-devops-for-mvps/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-12)"

# === RELATED UNITS ===
related_kos:
  related_to:
    - id: "software/landing-pages/landing-page-platform-deployment/2026"
      label: "Simpler deployment for static landing pages"
  alternative_to: []

# === SOURCES ===
sources:
  - id: src1
    title: "Vercel Pricing: Hobby, Pro, and Enterprise Plans"
    author: Vercel
    url: https://vercel.com/pricing
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src2
    title: "Pricing Plans — Railway Docs"
    author: Railway
    url: https://docs.railway.com/reference/pricing/plans
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src3
    title: "Fly.io Resource Pricing"
    author: Fly.io
    url: https://fly.io/docs/about/pricing/
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src4
    title: "AWS Amplify Pricing"
    author: Amazon Web Services
    url: https://aws.amazon.com/amplify/pricing/
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src5
    title: "Railway vs. Vercel — Railway Docs"
    author: Railway
    url: https://docs.railway.com/platform/compare-to-vercel
    type: official_docs
    published: 2025-01-01
    reliability: high
  - id: src6
    title: "Railway vs Render 2026: Honest Cost & Speed Breakdown"
    author: The Software Scout
    url: https://thesoftwarescout.com/railway-vs-render-2026-best-platform-for-deploying-apps/
    type: technical_blog
    published: 2026-01-15
    reliability: high
  - id: src7
    title: "AWS Amplify: Complete Guide to Build, Host & Scale App"
    author: NetCom Learning
    url: https://www.netcomlearning.com/blog/what-is-aws-amplify
    type: technical_blog
    published: 2025-06-01
    reliability: high
---

# Deployment & DevOps for MVPs

## Purpose

This recipe deploys a full-stack MVP to production with CI/CD pipelines, environment variable management, error tracking, and uptime monitoring — covering five platforms (Vercel, Railway, Fly.io, AWS Amplify, Render) with platform-specific setup instructions, cost benchmarks, and monitoring integration. The output is a live application with automated deployments on every Git push, proper secret management, error alerting, and uptime monitoring. [src1]

## Prerequisites

- [ ] **Application codebase in Git** — pushed to GitHub or GitLab with a working local development setup
- [ ] **Environment variables documented** — list of all API keys, database URLs, and secrets needed at runtime
- [ ] **Deployment platform account** — free account at [Vercel](https://vercel.com/signup), [Railway](https://railway.com), [Fly.io](https://fly.io/app/sign-up), [AWS](https://aws.amazon.com/amplify/), or [Render](https://render.com)
- [ ] **Sentry account** (recommended) — free at [sentry.io/signup](https://sentry.io/signup/) for error tracking (5K errors/mo free)
- [ ] **Node.js 18+** or your runtime installed locally for CLI-based deployments
- [ ] **Custom domain** (optional) — registered at Cloudflare, Namecheap, or Porkbun ($10-15/yr)

## Constraints

- Vercel Hobby plan is non-commercial only. Any revenue-generating MVP requires Pro at $20/user/mo. [src1]
- Railway charges from first minute of usage — no free tier since 2024. Hobby: $5/mo base + $5 credit. [src2]
- Fly.io has no general free tier for new orgs. Budget minimum ~$2-5/mo for a basic app. [src3]
- AWS Amplify free tier: 5 GB stored, 1 GB served, 1000 build minutes/mo. New accounts get up to $200 in credits. [src4]
- Environment secrets must use platform-native secret management (not .env files committed to Git). Leaked secrets in Git history persist even after deletion.
- Database connections from serverless functions require connection pooling (PgBouncer, Supabase connection pooler, or Prisma Accelerate) to avoid exhausting connection limits.

## Tool Selection Decision

```
Which path?
├── Frontend-only MVP (Next.js, Astro, React SPA)
│   ├── budget = free → PATH A: Vercel Hobby (non-commercial)
│   └── budget > $0 → PATH B: Vercel Pro ($20/mo)
├── Full-stack MVP (frontend + API + database)
│   ├── budget < $10/mo → PATH C: Railway Hobby ($5/mo + usage)
│   ├── budget $10-50/mo → PATH D: Railway Pro ($20/mo) or Render ($7-25/mo)
│   └── budget > $50/mo → PATH E: Fly.io or AWS Amplify
├── API/backend only (no frontend)
│   ├── budget < $10/mo → PATH C: Railway Hobby
│   └── budget > $10/mo → PATH D: Railway Pro or Fly.io
└── Already in AWS ecosystem
    └── PATH F: AWS Amplify (leverage existing credits/services)
```

| Path | Tools | Cost/mo | CI/CD | Best For |
|------|-------|---------|-------|----------|
| A: Vercel Hobby | Vercel + Supabase | $0 | Git push auto-deploy | Non-commercial frontend MVPs |
| B: Vercel Pro | Vercel + Supabase/Neon | $20+ | Git push + preview deploys | Commercial Next.js MVPs |
| C: Railway Hobby | Railway (app + DB) | $5-15 | Git push auto-deploy | Side projects, early MVPs |
| D: Railway Pro / Render | Railway or Render | $20-50 | Git push + staging envs | Production MVPs with databases |
| E: Fly.io | Fly.io + managed DB | $20-80 | flyctl deploy + GH Actions | Global low-latency apps |
| F: AWS Amplify | Amplify + RDS/DynamoDB | $0-50 (credits) | Amplify CI/CD pipeline | AWS-centric teams |

## Execution Flow

### Step 1: Connect Repository and Initial Deploy

**Duration**: 10-15 minutes
**Tool**: Deployment platform dashboard or CLI

**For Vercel (frontend or Next.js full-stack):**

```bash
# Option 1: Dashboard (recommended for first deploy)
# vercel.com → New Project → Import Git Repository → select repo
# Vercel auto-detects Next.js, Astro, Remix, SvelteKit

# Option 2: CLI
npm i -g vercel
cd your-mvp-project
vercel

# For production deployment:
vercel --prod
```

**For Railway (full-stack with database):**

```bash
# Option 1: Dashboard
# railway.com → New Project → Deploy from GitHub repo
# Railway auto-detects Node.js, Python, Go, Rust, Docker

# Option 2: CLI
npm i -g @railway/cli
railway login
cd your-mvp-project
railway init
railway up

# Add a database:
railway add --database postgres
# Connection string auto-injected as DATABASE_URL
```

**For Fly.io (global edge deployment):**

```bash
# Install flyctl
curl -L https://fly.io/install.sh | sh

# Login and launch
fly auth login
cd your-mvp-project
fly launch
# Follow prompts: app name, region, resources

# Deploy
fly deploy

# Add PostgreSQL:
fly postgres create --name your-app-db
fly postgres attach your-app-db
```

**For AWS Amplify:**

```bash
# Option 1: Amplify Console (recommended)
# AWS Console → Amplify → New app → Host web app → Connect GitHub
# Configure build settings (auto-detected for React, Next.js)

# Option 2: CLI
npm i -g @aws-amplify/cli
amplify init
amplify push
```

**For Render:**

```bash
# Dashboard only — render.com → New → Web Service → Connect GitHub
# Select repo, choose runtime, set build and start commands
# Example for Node.js:
#   Build: npm install && npm run build
#   Start: npm start
```

**Verify**: Application loads at the platform-provided subdomain (e.g., your-app.vercel.app, your-app.up.railway.app, your-app.fly.dev, or your-app.onrender.com). [src1] [src2]
**If failed**: Check build logs in platform dashboard. Common causes: missing build command, wrong output directory, Node.js version mismatch. Set explicit Node version in package.json engines field.

### Step 2: Configure Environment Variables

**Duration**: 5-10 minutes
**Tool**: Platform dashboard or CLI

Every platform has a secrets/environment variables panel. Never commit secrets to Git.

**For Vercel:**

```bash
# CLI approach (recommended for automation)
vercel env add DATABASE_URL production
# Paste value when prompted

# Or add via dashboard: Project Settings → Environment Variables
# Set scope: Production, Preview, Development

# Pull env vars for local dev:
vercel env pull .env.local
```

**For Railway:**

```bash
# CLI
railway variables set DATABASE_URL="postgresql://..."
railway variables set STRIPE_SECRET_KEY="sk_live_..."

# Or dashboard: Project → Variables tab
# Variables auto-injected into all deployments
# Shared variables: create a shared variable group for multi-service repos
```

**For Fly.io:**

```bash
# Secrets (encrypted, not visible in dashboard after setting)
fly secrets set DATABASE_URL="postgresql://..."
fly secrets set STRIPE_SECRET_KEY="sk_live_..."

# List current secrets (names only, values hidden)
fly secrets list
```

**For AWS Amplify:**

```bash
# Dashboard: App settings → Environment variables
# Or amplify.yml build config:
# environment:
#   variables:
#     DATABASE_URL: ${DATABASE_URL}

# For sensitive values, use AWS SSM Parameter Store:
aws ssm put-parameter --name "/myapp/DATABASE_URL" --value "postgresql://..." --type SecureString
```

**Verify**: Application starts successfully with all environment variables loaded. Check application logs for any "undefined" or "missing env var" errors.
**If failed**: Verify variable names match exactly (case-sensitive). On Vercel, ensure variables are set for the correct environment (Production vs Preview). Redeploy after adding variables.

### Step 3: Set Up CI/CD Pipeline

**Duration**: 10-15 minutes
**Tool**: Platform settings + GitHub Actions (optional)

All five platforms include basic CI/CD (auto-deploy on push). This step adds testing, staging environments, and quality gates.

**Vercel/Railway/Render (built-in CI/CD):**

```yaml
# .github/workflows/ci.yml — add tests before platform auto-deploys
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm test
```

**Vercel preview deployments (automatic):**

```bash
# Every pull request gets a unique preview URL automatically
# Configure in vercel.json:
{
  "github": {
    "autoAlias": true,
    "silent": true
  }
}

# Access preview at: your-app-git-branch-name.vercel.app
```

**Fly.io (GitHub Actions deploy):**

```yaml
# .github/workflows/deploy.yml
name: Deploy to Fly.io
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: superfly/flyctl-actions/setup-flyctl@master
      - run: flyctl deploy --remote-only
        env:
          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
```

**Staging environment setup:**

```bash
# Vercel: automatic per-branch previews, no config needed

# Railway: create a staging environment
railway environment create staging
# Deploy to staging: push to staging branch

# Fly.io: create a staging app
fly apps create your-app-staging
fly deploy --app your-app-staging

# Render: use Preview Environments (auto-created for PRs)
```

**Verify**: Push a commit to a feature branch and confirm: (1) CI tests run and pass, (2) preview/staging deployment is created, (3) merging to main triggers production deploy. [src1] [src5]
**If failed**: Check GitHub Actions logs for test failures. Verify platform webhook is connected (Settings → Webhooks in GitHub repo).

### Step 4: Add Monitoring and Error Tracking

**Duration**: 10-15 minutes
**Tool**: Sentry + BetterStack/UptimeRobot

**Sentry error tracking setup:**

```bash
# Install Sentry SDK
npm install @sentry/node @sentry/profiling-node

# Initialize in your app entry point (e.g., server.js or instrumentation.ts)
```

```javascript
// sentry.server.config.js (or instrumentation.ts for Next.js)
import * as Sentry from "@sentry/node";

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 0.1,  // 10% of transactions for performance monitoring
  profilesSampleRate: 0.1,
});
```

```bash
# For Next.js specifically:
npx @sentry/wizard@latest -i nextjs
# Wizard auto-configures sentry.client.config.ts, sentry.server.config.ts, and next.config.js
```

**Uptime monitoring setup:**

```
BetterStack (formerly Better Uptime):
───────────────────────────────────────
1. Sign up at betterstack.com (free: 10 monitors)
2. Add monitor → HTTP(S) → enter your production URL
3. Set check interval: 3 minutes
4. Add notification: email + Slack webhook
5. Create status page (optional): status.yourapp.com

Alternative: UptimeRobot
1. Sign up at uptimerobot.com (free: 50 monitors)
2. Add monitor → HTTP(s) → enter URL
3. Set check interval: 5 minutes (free tier minimum)
```

**Basic health check endpoint:**

```javascript
// /api/health.js (or /api/health/route.ts for Next.js App Router)
export async function GET() {
  try {
    // Check database connectivity
    await db.query('SELECT 1');
    return Response.json({
      status: 'healthy',
      timestamp: new Date().toISOString(),
      version: process.env.COMMIT_SHA || 'unknown'
    });
  } catch (error) {
    return Response.json(
      { status: 'unhealthy', error: error.message },
      { status: 503 }
    );
  }
}
```

**Verify**: (1) Trigger a test error in Sentry and confirm it appears in the dashboard within 30 seconds. (2) Confirm uptime monitor shows "UP" status for your production URL.
**If failed**: Check Sentry DSN is correctly set as environment variable. Verify uptime monitor URL is accessible from external networks (not localhost).

### Step 5: Configure Custom Domain and SSL

**Duration**: 5-15 minutes
**Tool**: Platform dashboard + DNS registrar

```bash
# Vercel
vercel domains add yourdomain.com
# Then add DNS records at registrar:
# A     @     76.76.21.21
# CNAME www   cname.vercel-dns.com

# Railway
# Dashboard → Project → Settings → Domains → Add custom domain
# Railway provides CNAME target — add at registrar

# Fly.io
fly certs create yourdomain.com
# Add CNAME: yourdomain.com → your-app.fly.dev

# Render
# Dashboard → Service → Settings → Custom Domains → Add
# Render provides CNAME target

# AWS Amplify
# Amplify Console → Domain management → Add domain
# Auto-configures if domain is in Route 53
```

**Verify**: Visit https://yourdomain.com — loads with valid SSL certificate (padlock icon). HTTP redirects to HTTPS automatically.
**If failed**: DNS propagation takes up to 48 hours. Check with `dig +short yourdomain.com` or dnschecker.org. SSL auto-provisions after DNS resolves.

### Step 6: Set Up Log Aggregation (Optional)

**Duration**: 10 minutes
**Tool**: Platform-native logs or external service

```bash
# Vercel: built-in runtime logs
# Dashboard → Project → Logs → Runtime logs
# Or use Vercel Log Drains for external services:
vercel integrations add datadog  # or betterstack, axiom

# Railway: built-in log viewer
# Dashboard → Service → Logs
# Structured JSON logs recommended

# Fly.io: built-in log viewer
fly logs
# Or ship to external service:
fly logs --json | your-log-processor

# Render: built-in log viewer
# Dashboard → Service → Logs
```

**Verify**: Generate a few requests to your app and confirm log entries appear in the platform dashboard within 60 seconds.
**If failed**: Ensure your application outputs to stdout/stderr (not file-based logging). Platform log viewers only capture stdout/stderr streams.

## Output Schema

```json
{
  "output_type": "deployed_mvp_infrastructure",
  "format": "live URL + CI/CD pipeline + monitoring",
  "columns": [
    {"name": "production_url", "type": "string", "description": "Custom domain or platform subdomain where MVP is live", "required": true},
    {"name": "platform", "type": "string", "description": "Hosting platform (Vercel/Railway/Fly.io/Amplify/Render)", "required": true},
    {"name": "cicd_status", "type": "string", "description": "CI/CD pipeline status (active/disabled)", "required": true},
    {"name": "preview_url_pattern", "type": "string", "description": "URL pattern for preview deployments", "required": false},
    {"name": "sentry_dsn", "type": "string", "description": "Sentry DSN for error tracking", "required": false},
    {"name": "uptime_monitor_url", "type": "string", "description": "URL of uptime monitoring dashboard", "required": false},
    {"name": "monthly_cost", "type": "number", "description": "Current monthly infrastructure cost in USD", "required": true},
    {"name": "ssl_status", "type": "string", "description": "SSL certificate status (valid/pending/error)", "required": true}
  ],
  "expected_row_count": "1",
  "sort_order": "N/A",
  "deduplication_key": "production_url"
}
```

## Quality Benchmarks

| Quality Metric | Minimum Acceptable | Good | Excellent |
|---------------|-------------------|------|-----------|
| Deploy time (push to live) | < 10 minutes | < 3 minutes | < 1 minute |
| Preview deployment exists | No | Yes, per PR | Yes, with seeded test data |
| Error tracking active | No tracking | Sentry captures errors | Sentry + performance monitoring |
| Uptime monitoring | None | 5-min check interval | 1-min check + status page |
| SSL certificate | Valid, no warnings | A rating on ssllabs.com | A+ rating |
| Health check endpoint | None | Returns 200 OK | Checks DB + external deps |
| Rollback capability | Redeploy old commit | 1-click rollback in dashboard | Automatic rollback on health check failure |

**If below minimum**: Focus on CI/CD pipeline first (Step 3), then add monitoring (Step 4). A working deploy pipeline with tests is more valuable than monitoring a broken deployment process.

## Error Handling

| Error | Likely Cause | Recovery Action |
|-------|-------------|----------------|
| Build failed: "Module not found" | Missing dependency in package.json | Run `npm install {module}`, commit package.json and lockfile, redeploy |
| Build failed: "Node.js version mismatch" | Platform default Node version differs from local | Add `"engines": {"node": ">=20"}` to package.json, or set Node version in platform settings |
| Deploy timeout | Build takes too long or app fails to start | Check for missing env vars, increase build timeout in platform settings, verify start command |
| 502 Bad Gateway after deploy | App crashed on startup | Check runtime logs for startup errors — usually missing env vars or failed DB connection |
| Database connection refused | Wrong connection string or firewall rules | Verify DATABASE_URL, ensure DB allows connections from platform IP ranges, check connection pooling |
| "Too many connections" | Serverless functions opening new DB connections per request | Implement connection pooling: Supabase pooler, PgBouncer, or Prisma Accelerate |
| Rate limit: 429 Too Many Requests | Platform or API rate limit exceeded | Implement request throttling, add caching layer, or upgrade plan |

## Cost Breakdown

| Component | Free Tier | Startup ($20-50/mo) | Growth ($50-200/mo) |
|-----------|-----------|---------------------|---------------------|
| Vercel hosting | Hobby: $0 (non-commercial) | Pro: $20/user/mo | Pro + usage overage |
| Railway hosting | N/A (no free tier) | Hobby: $5 + usage (~$10-20) | Pro: $20 + usage (~$30-80) |
| Fly.io hosting | N/A (no free tier) | ~$5-15/mo (shared CPU) | ~$20-60/mo (dedicated CPU) |
| AWS Amplify | Free tier ($200 credit) | ~$5-20/mo after credits | ~$20-80/mo |
| Render hosting | Free: 750 hrs/mo | Starter: $7/service | Standard: $25/service |
| Database (managed) | Supabase free / Neon free | Supabase Pro: $25/mo | Railway PG: $10-30/mo |
| Error tracking | Sentry free: 5K errors | Sentry Team: $26/mo | Sentry Business: $80/mo |
| Uptime monitoring | UptimeRobot free | BetterStack: $10/mo | Checkly: $30/mo |
| **Total** | **$0** | **$20-60/mo** | **$80-250/mo** |

## Anti-Patterns

### Wrong: Deploying without environment variable management
Hardcoding API keys, database URLs, or secrets directly in source code. Even private repos can leak — credentials in Git history persist forever even after deletion. [src1]

### Correct: Use platform-native secret management
Store all secrets as platform environment variables (Vercel env vars, Railway variables, Fly.io secrets). Use `.env.local` for development only with `.gitignore` protection. Run `git log --all --full-history -S "sk_live"` to audit for leaked secrets.

### Wrong: No health checks or monitoring on production
Deploying an MVP and only discovering it's down when users complain. Without monitoring, silent failures (database disconnects, memory leaks) go undetected for hours. [src6]

### Correct: Health check endpoint + uptime monitor from day one
Add a `/api/health` endpoint that checks database connectivity and returns status. Configure an uptime monitor (free UptimeRobot or BetterStack) to ping it every 5 minutes with Slack/email alerts.

### Wrong: Using the same database for development and production
A single misconfigured migration or accidental data deletion in development destroys production data.

### Correct: Separate databases per environment
Use separate database instances for development, staging, and production. Railway and Render auto-create per-environment databases. For Vercel + Supabase, create separate Supabase projects.

## When This Matters

Use this recipe when the agent needs to take a working MVP codebase from a local development environment to a production deployment with CI/CD, environment management, and monitoring. Requires the application code to exist and work locally. This recipe handles infrastructure, not application development.

## Related Units

- [MVP Tech Stack Selection Guide](/software/mvp-development/mvp-tech-stack-selection-guide/2026) — choose your stack before deploying
- [Landing Page Platform Deployment](/software/landing-pages/landing-page-platform-deployment/2026) — simpler deployment for static landing pages
- [Startup Analytics Implementation Guide](/business/startup-metrics/startup-analytics-implementation-guide/2026) — add analytics after deployment
- [Startup Incident Response Playbook](/business/startup-operations/startup-incident-response-playbook/2026) — handle production incidents