Production Deployment

Learn more about Mintlify

Enter your email to receive updates about new features and product releases.

Deployment Architecture
Option 1: Vercel + Railway (Recommended)
Deploy API to Railway
Deploy Web to Vercel
Option 2: Docker Deployment
API Dockerfile
Web Dockerfile
Docker Compose
Option 3: All-in-One Platforms
Render
Fly.io
Production Considerations
Performance
Security
Monitoring
Scaling
Environment Variables Checklist
Deployment Checklist
Troubleshooting
Next Steps

Drift is a monorepo with two main services: a Next.js frontend and an Express API. This guide covers production deployment strategies.

Deployment Architecture

┌─────────────────┐
│   Next.js Web   │  (Vercel, Netlify, etc.)
│   Port 3000     │
└────────┬────────┘
         │ HTTP
         ▼
┌─────────────────┐
│   Express API   │  (Railway, Render, Fly.io, etc.)
│   Port 3001     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  External APIs  │
│  - Nessie       │
│  - Gemini       │
│  - ElevenLabs   │
│  - Plaid        │
└─────────────────┘

Option 1: Vercel + Railway (Recommended)

Deploy the frontend to Vercel and the backend to Railway for optimal performance.

Deploy API to Railway

Create Railway project

Sign up at railway.app
Click “New Project” → “Deploy from GitHub repo”
Select your Drift repository

Configure build settings

In Railway project settings:Root Directory: apps/apiBuild Command:

npm install && npm run build

Start Command:

npm start

Watch Paths: apps/api/**

Set environment variables

Add to Railway environment variables:

NESSIE_API_KEY=your_key
GEMINI_API_KEY=your_key
ELEVENLABS_API_KEY=your_key
PLAID_CLIENT_ID=your_id
PLAID_SECRET=your_secret
PLAID_ENV=production
PORT=3001

Use production API keys, not development/sandbox keys.

Deploy

Railway auto-deploys on push to your main branch. Note the generated URL:

https://drift-api-production.up.railway.app

Deploy Web to Vercel

Connect repository

Sign up at vercel.com
Click “Add New” → “Project”
Import your Drift GitHub repository

Configure build settings

Framework Preset: Next.jsRoot Directory: apps/webBuild Command:

cd ../.. && npm run build --filter=web

Output Directory: apps/web/.nextInstall Command:

npm install

Set environment variables

In Vercel project settings → Environment Variables:

NEXT_PUBLIC_API_URL=https://drift-api-production.up.railway.app

Only variables prefixed with NEXT_PUBLIC_ are accessible in the browser.

Deploy

Click “Deploy”. Vercel builds and deploys automatically.Your production URL:

https://drift-production.vercel.app

Option 2: Docker Deployment

Deploy both services using Docker containers.

API Dockerfile

Create apps/api/Dockerfile:

FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./
COPY apps/api/package*.json ./apps/api/

# Install dependencies
RUN npm install

# Copy source
COPY apps/api ./apps/api
COPY turbo.json ./

# Build
RUN npm run build --workspace=apps/api

# Production image
FROM node:18-alpine

WORKDIR /app

# Copy built assets
COPY --from=builder /app/apps/api/dist ./dist
COPY --from=builder /app/apps/api/package*.json ./

# Install production dependencies only
RUN npm install --production

EXPOSE 3001

CMD ["node", "dist/index.js"]

Web Dockerfile

Create apps/web/Dockerfile:

FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./
COPY apps/web/package*.json ./apps/web/

# Install dependencies
RUN npm install

# Copy source
COPY apps/web ./apps/web
COPY turbo.json ./

# Build
ARG NEXT_PUBLIC_API_URL
ENV NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
RUN npm run build --workspace=apps/web

# Production image
FROM node:18-alpine

WORKDIR /app

# Copy built assets
COPY --from=builder /app/apps/web/.next ./.next
COPY --from=builder /app/apps/web/public ./public
COPY --from=builder /app/apps/web/package*.json ./

# Install production dependencies
RUN npm install --production

EXPOSE 3000

CMD ["npm", "start"]

Docker Compose

Create docker-compose.yml at the repository root:

version: '3.8'

services:
  api:
    build:
      context: .
      dockerfile: apps/api/Dockerfile
    ports:
      - "3001:3001"
    environment:
      - NESSIE_API_KEY=${NESSIE_API_KEY}
      - GEMINI_API_KEY=${GEMINI_API_KEY}
      - ELEVENLABS_API_KEY=${ELEVENLABS_API_KEY}
      - PLAID_CLIENT_ID=${PLAID_CLIENT_ID}
      - PLAID_SECRET=${PLAID_SECRET}
      - PLAID_ENV=production
      - PORT=3001
    restart: unless-stopped

  web:
    build:
      context: .
      dockerfile: apps/web/Dockerfile
      args:
        - NEXT_PUBLIC_API_URL=http://api:3001
    ports:
      - "3000:3000"
    environment:
      - NEXT_PUBLIC_API_URL=http://api:3001
    depends_on:
      - api
    restart: unless-stopped

Deploy with:

docker-compose up -d

Option 3: All-in-One Platforms

Render

Create Web Service

Build Command: cd apps/web && npm install && npm run build
Start Command: cd apps/web && npm start
Environment: NEXT_PUBLIC_API_URL=<your-api-url>

Create API Service

Build Command: cd apps/api && npm install && npm run build
Start Command: cd apps/api && npm start
Environment: Add all API keys

Fly.io

Install Fly CLI

curl -L https://fly.io/install.sh | sh

Deploy API

cd apps/api
fly launch
fly secrets set NESSIE_API_KEY=your_key GEMINI_API_KEY=your_key
fly deploy

Deploy Web

cd apps/web
fly launch
fly secrets set NEXT_PUBLIC_API_URL=https://drift-api.fly.dev
fly deploy

Production Considerations

Performance

Enable Python simulation for speed

Ensure Python 3.11+ is installed in your production environment:

# In Dockerfile
RUN apk add --no-cache python3 py3-pip
RUN pip3 install numpy pandas pydantic openai python-dotenv

The Python engine runs 100k simulations in ~500ms vs 3-5 seconds in TypeScript.

Cache simulation results

Implement Redis caching for repeated simulations:

// Example caching layer
const cacheKey = `sim:${hash(profile)}:${hash(goal)}`
const cached = await redis.get(cacheKey)
if (cached) return JSON.parse(cached)

const results = await runSimulation(profile, goal)
await redis.set(cacheKey, JSON.stringify(results), 'EX', 300) // 5 min TTL
return results

Use CDN for static assets

Vercel automatically serves Next.js static assets via CDN. For other platforms:

Configure CloudFront or Cloudflare
Set appropriate cache headers
Enable compression (gzip/brotli)

Security

Never expose API keys in client-side code!Only environment variables prefixed with NEXT_PUBLIC_ are sent to the browser. Keep sensitive keys server-side only.

Enable CORS properly

In production, restrict CORS to your frontend domain:

// apps/api/src/index.ts
app.use(cors({
  origin: process.env.ALLOWED_ORIGINS?.split(',') || 'http://localhost:3000',
  credentials: true,
}))

Set ALLOWED_ORIGINS=https://drift-production.vercel.app in Railway.

Rate limit API endpoints

Install and configure rate limiting:

npm install express-rate-limit --workspace=apps/api

import rateLimit from 'express-rate-limit'

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // 100 requests per window
})

app.use('/api/', limiter)

Validate API keys on startup

Add health checks that verify API connectivity:

// Verify Nessie API on startup
const response = await nessieService.getCustomers()
if (!response) {
  console.error('FATAL: Nessie API key invalid')
  process.exit(1)
}

Use environment-specific keys

Maintain separate API keys for each environment:

Development: Sandbox/test keys with generous rate limits
Staging: Production keys with test data
Production: Production keys with real data and strict limits

Monitoring

Add logging

Use a structured logging service like LogDNA, Datadog, or Papertrail:

import winston from 'winston'

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
  ],
})

Monitor API usage

Track API key usage in provider dashboards:

Gemini: Google AI Studio Console
ElevenLabs: ElevenLabs Dashboard
Plaid: Plaid Dashboard

Set up uptime monitoring

Use services like UptimeRobot or Better Uptime to monitor:

API health endpoint: https://your-api.com/health
Web app homepage: https://your-web.com

Set alerts for downtime > 1 minute.

Configure error tracking

Integrate Sentry for error monitoring:

npm install @sentry/node @sentry/nextjs

// apps/api/src/index.ts
import * as Sentry from '@sentry/node'

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
})

Scaling

For high-traffic scenarios, consider:

Horizontal scaling: Run multiple API instances behind a load balancer
Database: Move from in-memory storage to PostgreSQL for Plaid tokens
Queue: Use Bull/BullMQ for asynchronous simulation jobs
Compute: Offload heavy simulations to AWS Lambda or Cloud Functions

Environment Variables Checklist

Before deploying, ensure all required variables are set:

API Server
Web App

✅ NESSIE_API_KEY
✅ GEMINI_API_KEY
⚠️ ELEVENLABS_API_KEY (optional)
⚠️ PLAID_CLIENT_ID (optional)
⚠️ PLAID_SECRET (optional)
⚠️ PLAID_ENV (optional)
⚠️ OPENAI_API_KEY (optional)
✅ PORT (default: 3001)
⚠️ ALLOWED_ORIGINS (for CORS)

✅ NEXT_PUBLIC_API_URL

Deployment Checklist

Troubleshooting

CORS errors in production

Ensure ALLOWED_ORIGINS includes your production frontend domain:

ALLOWED_ORIGINS=https://drift.vercel.app,https://www.drift.app

API key errors

Verify environment variables are set in your hosting platform:

# Railway
railway variables

# Vercel
vercel env ls

Build failures

Check build logs for missing dependencies or TypeScript errors:

# Test build locally
npm run build

Slow simulations

Ensure Python is installed in production environment and NumPy dependencies are met.

Next Steps

Environment Variables

Review all configuration options

API Reference

Explore available endpoints

Performance Tuning

Optimize Monte Carlo simulation performance

API Keys

Configure external service credentials

Local Development

API Keys Configuration

⌘I

Build docs developers (and LLMs) love

Get started for free Talk to us

Setup

Configuration

​Deployment Architecture

​Option 1: Vercel + Railway (Recommended)

​Deploy API to Railway

​Deploy Web to Vercel

​Option 2: Docker Deployment

​API Dockerfile

​Web Dockerfile

​Docker Compose

​Option 3: All-in-One Platforms

​Render

​Fly.io

​Production Considerations

​Performance

​Security

​Monitoring

​Scaling

​Environment Variables Checklist

​Deployment Checklist

​Troubleshooting

​Next Steps

Environment Variables

API Reference

Performance Tuning

API Keys

Build docs developers (and LLMs) love

Deployment Architecture

Option 1: Vercel + Railway (Recommended)

Deploy API to Railway

Deploy Web to Vercel

Option 2: Docker Deployment

API Dockerfile

Web Dockerfile

Docker Compose

Option 3: All-in-One Platforms

Render

Fly.io

Production Considerations

Performance

Security

Monitoring

Scaling

Environment Variables Checklist

Deployment Checklist

Troubleshooting

Next Steps