Deployment Advisor

Deployment Advisor

Choose the right deployment strategy for your application scale and requirements.

Core Principle

Start simple, scale when needed. Don't over-engineer infrastructure for 10 users that won't arrive for months.

Deployment Tiers

Tier 1: MVP / Small Projects (<1,000 users)

Cost: $0-$20/month Time to Deploy: 5-15 minutes Best for: MVPs, prototypes, side projects, marketing sites

Recommended Platforms:

Vercel (Next.js, React, static sites):

• Push to GitHub → auto deploy
• Edge functions, image optimization
• Free SSL, global CDN
• $0 for hobby, $20/mo for team

Netlify (Static sites, Jamstack):

• Similar to Vercel, better for non-Next.js
• Form handling, split testing
• Serverless functions

Railway (Full-stack, databases):

• Deploys anything (Node, Python, Go, Rust)
• Integrated PostgreSQL, Redis, MongoDB
• $5/mo for 512MB RAM + usage

Cloudflare Pages (Static + Workers):

• Free unlimited bandwidth
• Edge functions (Workers)
• Fastest CDN globally

---

Tier 2: Growing Products (1K-100K users)

Cost: $20-$500/month Time to Deploy: 1-4 hours Best for: Validated products, growing startups, paid customers

Recommended Platforms:

AWS Amplify (Full-stack web apps):

• Managed hosting + backend
• Authentication, APIs, databases
• Auto-scaling, monitoring
• $50-200/mo typical

Google Cloud Run (Containerized apps):

• Pay only for actual usage
• Scales to zero
• Automatic HTTPS
• $20-100/mo for small traffic

Fly.io (Distributed apps):

• Global deployment (closer to users)
• PostgreSQL, Redis included
• Docker-based
• $50-200/mo

Render (Simpler alternative to AWS):

• Auto-deploy from Git
• PostgreSQL, Redis, cron jobs
• Free tier available
• $50-150/mo for production

---

Tier 3: Scale / Enterprise (100K+ users)

Cost: $500-$5,000+/month Time to Deploy: 1-4 weeks Best for: High traffic, enterprise, compliance requirements

Recommended Platforms:

AWS ECS (Containers, no Kubernetes complexity):

• Fargate (serverless containers)
• Full AWS ecosystem
• Fine-grained control
• $500-2000/mo typical

AWS EKS / Google GKE (Kubernetes):

• Full orchestration
• Multi-region, auto-scaling
• Complex but powerful
• $1000-5000+/mo

DigitalOcean App Platform (Mid-tier simplicity):

• Kubernetes-powered, no K8s knowledge needed
• Cheaper than AWS
• Good middle ground
• $200-1000/mo

---

Decision Framework

Question 1: What are you deploying?

Static site (HTML, CSS, JS): → Vercel, Netlify, Cloudflare Pages

Next.js app: → Vercel (best integration), Netlify

React/Vue/Angular SPA: → Vercel, Netlify, Cloudflare Pages

Node.js API: → Railway, Render, Fly.io, AWS Amplify

Python API (FastAPI, Flask, Django): → Railway, Render, Fly.io, Google Cloud Run

Go/Rust API: → Fly.io, Railway, Google Cloud Run

Full-stack (Frontend + Backend + DB): → Railway, Render, AWS Amplify

Microservices: → Fly.io, Google Cloud Run, AWS ECS

Question 2: Do you need a database?

No database: → Vercel, Netlify, Cloudflare Pages

Serverless database (PostgreSQL, MySQL): → Railway, Render (integrated), AWS RDS, Supabase

Redis/caching: → Railway, Render, AWS ElastiCache, Upstash

MongoDB: → MongoDB Atlas, Railway, AWS DocumentDB

Question 3: How many users?

<100 users (MVP): → Free/cheap tiers: Vercel free, Railway $5

100-1,000 users: → Vercel Pro ($20), Railway ($20-50), Render

1K-10K users: → Railway ($50-100), AWS Amplify, Cloud Run

10K-100K users: → AWS Amplify, Cloud Run, Fly.io ($100-500)

100K-1M users: → AWS ECS, GKE, dedicated servers ($500-5000)

Question 4: Geographic distribution?

Single region (US/Europe): → Any platform

Global (low latency worldwide): → Cloudflare Pages/Workers, Vercel Edge, Fly.io (multi-region)

China/Asia: → Cloudflare, Fly.io Hong Kong, Alibaba Cloud

Question 5: Special requirements?

Compliance (HIPAA, SOC 2, GDPR): → AWS, Google Cloud, Azure (compliance certifications)

Long-running jobs (>15 min): → Railway, Render Background Workers, AWS ECS

WebSockets/real-time: → Railway, Render, Fly.io, AWS ECS

High compute (video processing, ML): → AWS ECS/EKS, Google Cloud Run, dedicated GPUs

---

CI/CD Pipeline Setup

Tier 1: Git Push Auto-Deploy

Platforms: Vercel, Netlify, Railway, Render

Setup (5 minutes):

1. Connect GitHub/GitLab repo 2. Configure build command: npm run build 3. Configure output directory: dist or .next 4. Push to main branch → auto deploy

Environment Variables:

DATABASE_URL=postgresql://...
API_KEY=secret_key
NODE_ENV=production

Preview Deployments:

• Every pull request gets preview URL
• Test before merging to production

---

Tier 2: GitHub Actions CI/CD

Use when: Custom tests, security scans, multi-stage deploys

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm ci
      - run: npm test
      - run: npm run lint

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: amondnet/vercel-action@v20
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          vercel-args: '--prod'

---

Tier 3: Enterprise CI/CD

Features:

• Multi-environment (dev, staging, prod)
• Blue-green deployments
• Canary releases
• Automated rollbacks
• Security scanning (SAST, DAST)

Pipeline Stages:

Build → Test → Security Scan → Stage Deploy → Integration Tests → Prod Deploy

Tools:

• GitHub Actions, GitLab CI, CircleCI
• ArgoCD (GitOps for Kubernetes)
• Terraform (Infrastructure as Code)

---

Deployment Checklist

Pre-Launch

• [ ] Environment variables configured
• [ ] Database migrations tested
• [ ] SSL/HTTPS enabled
• [ ] Custom domain connected
• [ ] Error monitoring set up (Sentry, Rollbar)
• [ ] Analytics configured
• [ ] Backup strategy defined

Launch Day

• [ ] Deploy to production
• [ ] Verify all pages load
• [ ] Test critical user flows
• [ ] Check error monitoring dashboard
• [ ] Monitor performance metrics
• [ ] Have rollback plan ready

Post-Launch

• [ ] Monitor logs for errors
• [ ] Check performance (response times)
• [ ] Verify analytics tracking
• [ ] Review cost/usage
• [ ] Document any issues
• [ ] Plan scaling strategy

---

Common Deployment Patterns

Pattern 1: Jamstack (Static + API)

Stack: Next.js (Vercel) + API (Railway/Supabase)

Pros: Fast, cheap, scales easily Cons: Not suitable for real-time or server-heavy apps

Frontend (Vercel) → API (Railway) → Database (Supabase)

Pattern 2: Serverless

Stack: Vercel Functions + Serverless DB (Supabase/PlanetScale)

Pros: Zero server management, pay per use Cons: Cold starts, vendor lock-in

Frontend (Vercel) → Edge Functions (Vercel) → Serverless DB

Pattern 3: Traditional Full-Stack

Stack: Railway (Node.js + PostgreSQL)

Pros: Simple, everything in one place Cons: Single point of failure

Railway: Node.js API + PostgreSQL + Redis

Pattern 4: Microservices

Stack: Multiple Cloud Run services + Cloud SQL

Pros: Independent scaling, fault isolation Cons: Complex, higher cost

Frontend (Vercel) → Service 1 (Cloud Run) → Database
                 → Service 2 (Cloud Run) → Queue

---

Cost Optimization

Free Tier Strategy

• Vercel: Free for personal projects
• Supabase: 500MB DB, 50K API requests/day
• Railway: $5 credit/month (enough for small API)
• Cloudflare: Unlimited bandwidth free

Total: $0-5/month for MVP

Production Cost Optimization

• Use caching (Redis, CDN) to reduce compute
• Optimize images (Next.js Image, Cloudinary)
• Database connection pooling (PgBouncer)
• Monitor and right-size resources
• Use spot instances for non-critical workloads

---

Security Best Practices

Must-Haves

• ✅ HTTPS only (automatic on most platforms)
• ✅ Environment variables for secrets (never commit)
• ✅ Database encryption at rest
• ✅ Regular dependency updates
• ✅ Rate limiting on APIs

Recommended

• Security headers (helmet.js for Node)
• DDoS protection (Cloudflare)
• Automated vulnerability scanning
• Audit logs for sensitive operations
• Backup and disaster recovery plan

---

Monitoring & Observability

Tier 1: Basic Monitoring

• Platform dashboards (Vercel Analytics, Railway Metrics)
• Error tracking: Sentry ($0-26/mo)
• Uptime monitoring: UptimeRobot (free), Better Uptime

Tier 2: Enhanced Monitoring

• APM: New Relic, Datadog ($15-100/mo)
• Log aggregation: LogTail, Papertrail
• Custom metrics and alerting

Tier 3: Enterprise Observability

• Full stack: Datadog, New Relic ($300-1000+/mo)
• Distributed tracing (OpenTelemetry)
• Custom dashboards (Grafana)
• PagerDuty for incidents

---

Quick Start Recommendations

Simple marketing site: → Vercel + Contentful CMS

SaaS MVP: → Next.js (Vercel) + Supabase (DB + Auth) + Stripe

Internal tool: → React (Netlify) + FastAPI (Railway) + PostgreSQL (Railway)

Mobile app backend: → FastAPI (Cloud Run) + Cloud SQL + Firebase Auth

E-commerce: → Next.js (Vercel) + Shopify/Stripe + PostgreSQL (Supabase)

---

Related Resources

Related Skills:

• frontend-builder - For building apps to deploy
• api-designer - For API architecture
• performance-optimizer - For optimizing deployed apps

Related Patterns:

• META/DECISION-FRAMEWORK.md - Platform selection guidance
• STANDARDS/architecture-patterns/deployment-patterns.md - Deployment architectures (when created)

Related Playbooks:

• PLAYBOOKS/deploy-to-vercel.md - Vercel deployment guide (when created)
• PLAYBOOKS/setup-cicd.md - CI/CD setup procedure (when created)

Deployment Advisor - Quick Start

Version: 1.0.0 Category: Infrastructure & DevOps Difficulty: Intermediate

What This Skill Does

Guides deployment platform selection and infrastructure setup from MVP (Vercel, Railway) through scale (AWS ECS, Kubernetes) with cost-optimized recommendations.

When to Use

Use this skill when you need to:

• Choose where to deploy an application
• Set up CI/CD pipelines
• Configure production environments
• Optimize deployment costs
• Scale from MVP to production
• Implement monitoring and security

Quick Start

Fastest path to production:

1. Identify your tier (based on user count)

• Tier 1: <1K users → Vercel, Railway, Netlify ($0-20/mo)
• Tier 2: 1K-100K → AWS Amplify, Cloud Run, Fly.io ($20-500/mo)
• Tier 3: 100K+ → AWS ECS, GKE, enterprise ($500-5000+/mo)

2. Match platform to app type

• Static site → Vercel, Netlify, Cloudflare Pages
• Next.js → Vercel (best), Netlify
• Full-stack API + DB → Railway, Render
• Microservices → Cloud Run, Fly.io, ECS

3. Set up auto-deploy (Tier 1)

• Connect GitHub repo to platform
• Configure build command
• Push to main → auto deploy
• Time: 5-15 minutes

4. Configure CI/CD (Tier 2+)

• Add GitHub Actions workflow
• Run tests before deploy
• Multi-environment strategy
• Time: 1-4 hours

5. Launch checklist

• Environment variables set
• SSL/HTTPS enabled
• Domain connected
• Error monitoring (Sentry)
• Backups configured

Time to production: 15 minutes (Tier 1) to 1-4 weeks (Tier 3)

File Structure

deployment-advisor/
├── SKILL.md           # Main skill instructions (start here)
└── README.md          # This file

Prerequisites

Knowledge:

• Basic command line
• Git basics
• Understanding of your application stack

Tools:

• GitHub/GitLab account
• Platform account (Vercel, Railway, AWS, etc.)
• Domain name (optional for MVP)

Related Skills:

• frontend-builder or api-designer for building apps to deploy

Success Criteria

You've successfully used this skill when:

• ✅ Deployment platform chosen based on tier and requirements
• ✅ Application successfully deployed to production
• ✅ CI/CD pipeline configured (auto-deploy from Git)
• ✅ Environment variables and secrets secured
• ✅ Custom domain connected with HTTPS
• ✅ Error monitoring and logging set up
• ✅ Backup and rollback strategy defined
• ✅ Deployment costs within budget
• ✅ Performance monitoring in place

Common Workflows

Workflow 1: MVP Launch (Tier 1)

1. Use deployment-advisor to choose platform (Vercel for Next.js) 2. Connect GitHub repo to Vercel 3. Configure build settings 4. Add environment variables 5. Deploy to production (auto) 6. Connect custom domain 7. Cost: $0-20/month

Workflow 2: Growing Product (Tier 2)

1. Migrate from Tier 1 platform or start fresh 2. Choose Railway or Cloud Run 3. Set up GitHub Actions for CI/CD 4. Configure multi-environment (staging, production) 5. Add database (PostgreSQL) and Redis 6. Implement monitoring (Sentry, New Relic) 7. Cost: $50-200/month

Workflow 3: Enterprise Scale (Tier 3)

1. Use deployment-advisor enterprise guidance 2. Set up AWS ECS or Kubernetes (EKS/GKE) 3. Implement Infrastructure as Code (Terraform) 4. Configure blue-green or canary deployments 5. Full observability stack (Datadog, Prometheus) 6. Security scanning and compliance 7. Cost: $500-5000+/month

Key Concepts

Deployment Tiers:

• Tier 1 (<1K users): Simple platforms, auto-deploy, minimal config
• Tier 2 (1K-100K): Managed services, scaling, monitoring
• Tier 3 (100K+): Container orchestration, multi-region, HA

Platform Categories:

• Static Hosting: Vercel, Netlify, Cloudflare Pages
• Managed PaaS: Railway, Render, Fly.io, AWS Amplify
• Containers: Cloud Run, AWS ECS/Fargate
• Orchestration: Kubernetes (EKS, GKE, AKS)

CI/CD Levels:

• Level 1: Git push → auto deploy (Vercel, Railway built-in)
• Level 2: GitHub Actions → test → deploy (custom workflows)
• Level 3: Multi-stage, security scans, gradual rollout

Deployment Patterns:

• Jamstack: Static frontend + API backend
• Serverless: Edge functions + serverless DB
• Traditional: Monolith on single platform
• Microservices: Multiple services, independent deploy

Troubleshooting

Skill not activating?

• Try explicitly requesting: "Use the deployment-advisor skill to..."
• Mention keywords: "deployment", "hosting", "infrastructure", "CI/CD"

Can't choose between platforms?

• Start with tier based on user count
• Match platform to app type (see decision framework)
• Default recommendations:
• Next.js → Vercel
• Full-stack → Railway
• Microservices → Cloud Run

Deployment failing?

• Check build logs for errors
• Verify environment variables set correctly
• Ensure build command matches local setup
• Check Node.js version compatibility
• Review platform-specific requirements

High costs?

• Review usage metrics (compute, bandwidth, storage)
• Implement caching (Redis, CDN)
• Optimize images (Next.js Image component)
• Right-size resources (don't over-provision)
• Consider cheaper platform for your tier

Slow performance?

• Add CDN (built-in on most platforms)
• Enable caching (Redis for API responses)
• Optimize database queries
• Use connection pooling for databases
• Consider multi-region deployment

Security concerns?

• Ensure HTTPS enabled (automatic on modern platforms)
• Store secrets in environment variables (never commit)
• Enable security headers (helmet.js for Node)
• Add rate limiting to APIs
• Regular dependency updates
• Use platform-provided DDoS protection

Need to scale beyond current tier?

• Monitor key metrics (response time, error rate, costs)
• Plan migration 2-3 months before limits
• Test new platform with staging environment
• Use blue-green deployment for migration
• Keep rollback plan ready

Version History

• 1.0.0 (2025-10-21): Initial release, adapted from deployment-devops framework with practical tier-based guidance

License

Part of ai-dev-standards repository.