home / skills / jeremylongshore / claude-code-plugins-plus-skills / replit-deploy-integration

This skill helps you deploy Replit-powered apps to Vercel, Fly.io, or Cloud Run with secure secrets and production readiness.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill replit-deploy-integration

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.6 KB
---
name: replit-deploy-integration
description: |
  Deploy Replit integrations to Vercel, Fly.io, and Cloud Run platforms.
  Use when deploying Replit-powered applications to production,
  configuring platform-specific secrets, or setting up deployment pipelines.
  Trigger with phrases like "deploy replit", "replit Vercel",
  "replit production deploy", "replit Cloud Run", "replit Fly.io".
allowed-tools: Read, Write, Edit, Bash(vercel:*), Bash(fly:*), Bash(gcloud:*)
version: 1.0.0
license: MIT
author: Jeremy Longshore <[email protected]>
---

# Replit Deploy Integration

## Overview
Deploy Replit-powered applications to popular platforms with proper secrets management.

## Prerequisites
- Replit API keys for production environment
- Platform CLI installed (vercel, fly, or gcloud)
- Application code ready for deployment
- Environment variables documented

## Vercel Deployment

### Environment Setup
```bash
# Add Replit secrets to Vercel
vercel secrets add replit_api_key sk_live_***
vercel secrets add replit_webhook_secret whsec_***

# Link to project
vercel link

# Deploy preview
vercel

# Deploy production
vercel --prod
```

### vercel.json Configuration
```json
{
  "env": {
    "REPLIT_API_KEY": "@replit_api_key"
  },
  "functions": {
    "api/**/*.ts": {
      "maxDuration": 30
    }
  }
}
```

## Fly.io Deployment

### fly.toml
```toml
app = "my-replit-app"
primary_region = "iad"

[env]
  NODE_ENV = "production"

[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = true
  auto_start_machines = true
```

### Secrets
```bash
# Set Replit secrets
fly secrets set REPLIT_API_KEY=sk_live_***
fly secrets set REPLIT_WEBHOOK_SECRET=whsec_***

# Deploy
fly deploy
```

## Google Cloud Run

### Dockerfile
```dockerfile
FROM node:20-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["npm", "start"]
```

### Deploy Script
```bash
#!/bin/bash
# deploy-cloud-run.sh

PROJECT_ID="${GOOGLE_CLOUD_PROJECT}"
SERVICE_NAME="replit-service"
REGION="us-central1"

# Build and push image
gcloud builds submit --tag gcr.io/$PROJECT_ID/$SERVICE_NAME

# Deploy to Cloud Run
gcloud run deploy $SERVICE_NAME \
  --image gcr.io/$PROJECT_ID/$SERVICE_NAME \
  --region $REGION \
  --platform managed \
  --allow-unauthenticated \
  --set-secrets=REPLIT_API_KEY=replit-api-key:latest
```

## Environment Configuration Pattern

```typescript
// config/replit.ts
interface ReplitConfig {
  apiKey: string;
  environment: 'development' | 'staging' | 'production';
  webhookSecret?: string;
}

export function getReplitConfig(): ReplitConfig {
  const env = process.env.NODE_ENV || 'development';

  return {
    apiKey: process.env.REPLIT_API_KEY!,
    environment: env as ReplitConfig['environment'],
    webhookSecret: process.env.REPLIT_WEBHOOK_SECRET,
  };
}
```

## Health Check Endpoint

```typescript
// api/health.ts
export async function GET() {
  const replitStatus = await checkReplitConnection();

  return Response.json({
    status: replitStatus ? 'healthy' : 'degraded',
    services: {
      replit: replitStatus,
    },
    timestamp: new Date().toISOString(),
  });
}
```

## Instructions

### Step 1: Choose Deployment Platform
Select the platform that best fits your infrastructure needs and follow the platform-specific guide below.

### Step 2: Configure Secrets
Store Replit API keys securely using the platform's secrets management.

### Step 3: Deploy Application
Use the platform CLI to deploy your application with Replit integration.

### Step 4: Verify Health
Test the health check endpoint to confirm Replit connectivity.

## Output
- Application deployed to production
- Replit secrets securely configured
- Health check endpoint functional
- Environment-specific configuration in place

## Error Handling
| Issue | Cause | Solution |
|-------|-------|----------|
| Secret not found | Missing configuration | Add secret via platform CLI |
| Deploy timeout | Large build | Increase build timeout |
| Health check fails | Wrong API key | Verify environment variable |
| Cold start issues | No warm-up | Configure minimum instances |

## Examples

### Quick Deploy Script
```bash
#!/bin/bash
# Platform-agnostic deploy helper
case "$1" in
  vercel)
    vercel secrets add replit_api_key "$REPLIT_API_KEY"
    vercel --prod
    ;;
  fly)
    fly secrets set REPLIT_API_KEY="$REPLIT_API_KEY"
    fly deploy
    ;;
esac
```

## Resources
- [Vercel Documentation](https://vercel.com/docs)
- [Fly.io Documentation](https://fly.io/docs)
- [Cloud Run Documentation](https://cloud.google.com/run/docs)
- [Replit Deploy Guide](https://docs.replit.com/deploy)

## Next Steps
For webhook handling, see `replit-webhooks-events`.

Overview

This skill deploys Replit-powered applications to Vercel, Fly.io, and Google Cloud Run with secure secrets management and deployment scripts. It streamlines platform-specific setup, provides configuration patterns, and includes health check and deployment examples for production-ready releases.

How this skill works

The skill inspects your project for Replit integration points, then guides you to store API keys and webhook secrets using each platform's secret manager. It provides CLI commands, example config files (vercel.json, fly.toml, Dockerfile), and deploy scripts to push builds and configure runtime environment variables. Finally, it suggests a health check endpoint and validation steps to confirm connectivity.

When to use it

  • Deploy a Replit-backed app to production on Vercel, Fly.io, or Cloud Run
  • Configure and rotate Replit API keys and webhook secrets securely
  • Automate deployment pipelines with platform CLIs and scripts
  • Verify Replit connectivity and monitor health post-deploy
  • Prototype multi-environment (dev/staging/production) deployments

Best practices

  • Store secrets via platform secret managers (vercel secrets, fly secrets, Cloud Run secrets) rather than embedding them in code
  • Document environment variables and use an environment config module to centralize access
  • Use a health check endpoint to validate Replit connectivity after each deploy
  • Test deployments in a staging environment before promoting to production
  • Increase build or deploy timeouts for large apps and configure minimum instances to reduce cold starts

Example use cases

  • Deploy a Node.js Replit integration to Vercel using vercel.json and secrets for REPLIT_API_KEY
  • Run fly deploy with fly.toml and fly secrets set to host a Replit-powered service in a specified region
  • Build and push a container to Google Cloud Run with a Dockerfile and a deploy script that sets secrets
  • Create a quick deploy helper script to standardize production deploys across teams
  • Add a /api/health endpoint that checks Replit API reachability for uptime monitoring

FAQ

What secrets do I need to deploy?

You need a Replit API key and optional webhook secret. Store them using the platform's secret manager before deploying.

Which platform is best for low-latency webhooks?

Vercel and Cloud Run both offer managed routing with fast cold-start mitigation options; choose based on regional needs and instance control.