Free Tier:
- 512MB RAM
- 1 vCPU
- 1GB bandwidth/month
- PostgreSQL database included
- Custom domains

Pro Tier ($5/month):
- 8GB RAM
- 8 vCPUs
- 100GB bandwidth/month
- Multiple environments
- Priority support

Basic Tier ($5/month):
- 512MB RAM
- 1 vCPU
- 40GB bandwidth
- 3 regions available

Professional Tier ($12/month):
- 1GB RAM
- 1 vCPU
- 400GB bandwidth
- Autoscaling 1-10 instances

Free Tier:
- 512MB RAM
- 0.1 CPU
- 750 hours/month
- Sleeps after 15 min inactivity

Starter ($7/month):
- 512MB RAM
- 0.5 CPU
- Always-on
- Custom domains

Pay-per-use:
- $0.24 per million requests
- $0.00000025 per GB-second
- $0.00001 per vCPU-second
- 2 million requests free/month

Example Cost for Medium Bot:
- 100k requests/month: ~$0.50
- 1M requests/month: ~$2.40

Shared CPU (Most Common):
- 256MB RAM: $1.94/month
- 512MB RAM: $3.33/month
- 1GB RAM: $5.69/month
- Additional regions: +$2/month each

Eco Dyno ($5/month):
- 512MB RAM
- Sleeps after 30 min inactivity
- 1000 dyno hours/month

Basic Dyno ($7/month):
- 512MB RAM
- Always-on
- Metrics and logging

Regular Performance:
- $2.50/month: 512MB RAM, 1 vCPU, 10GB SSD
- $5/month: 1GB RAM, 1 vCPU, 25GB SSD
- $10/month: 2GB RAM, 1 vCPU, 55GB SSD

High Frequency:
- $6/month: 1GB RAM, 1 vCPU, 25GB NVMe
- $12/month: 2GB RAM, 1 vCPU, 50GB NVMe

Shared CPU:
- $5/month: 1GB RAM, 1 vCPU, 25GB SSD
- $10/month: 2GB RAM, 1 vCPU, 50GB SSD
- $20/month: 4GB RAM, 2 vCPU, 80GB SSD

Shared vCPU:
- €3.29/month: 2GB RAM, 1 vCPU, 20GB SSD
- €5.83/month: 4GB RAM, 2 vCPU, 40GB SSD
- €11.05/month: 8GB RAM, 2 vCPU, 80GB SSD

Always Free Resources:
- 2 VM instances (1/8 OCPU each)
- 1GB RAM total
- 100GB block storage
- 10TB bandwidth/month

Basic Plan: $3-5/month
- 1 bot instance
- Basic monitoring
- Community support

Premium Plan: $10-15/month
- Multiple bots
- Advanced features
- Priority support

# Ensure your bot has these files:
package.json          # Node.js dependencies
requirements.txt      # Python dependencies (if using Python)
Procfile             # Optional: specify start command
.env.example         # Template for environment variables
README.md           # Documentation

{
  "name": "my-discord-bot",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "dependencies": {
    "discord.js": "^14.14.1",
    "dotenv": "^16.3.1"
  },
  "engines": {
    "node": ">=18.0.0"
  }
}

# In Railway dashboard, go to Variables tab
DISCORD_BOT_TOKEN=your_bot_token_here
DISCORD_CLIENT_ID=your_client_id
NODE_ENV=production
DATABASE_URL=postgresql://... # Auto-generated if you add PostgreSQL

# View logs in real-time
railway logs

# Check metrics
railway status

# Deploy updates
git push origin main  # Automatic deployment

name: discord-bot
services:
- name: bot
  source_dir: /
  github:
    repo: your-username/your-bot-repo
    branch: main
  run_command: npm start
  environment_slug: node-js
  instance_count: 1
  instance_size_slug: basic-xxs
  envs:
  - key: DISCORD_BOT_TOKEN
    scope: RUN_TIME
    type: SECRET
  - key: NODE_ENV
    value: production
    scope: RUN_TIME
databases:
- name: bot-db
  engine: PG
  version: "13"
  size: db-s-dev-database

FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Create non-root user
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
USER nextjs

# Expose port
EXPOSE 8080

# Start the application
CMD ["npm", "start"]

# Build and deploy
gcloud builds submit --tag gcr.io/PROJECT_ID/discord-bot
gcloud run deploy discord-bot \
  --image gcr.io/PROJECT_ID/discord-bot \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --memory 512Mi \
  --cpu 1 \
  --max-instances 10

// Optimize intents (only request what you need)
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages
    // Don't include MessageContent unless absolutely necessary
  ],
  // Reduce cache sizes
  makeCache: Options.cacheWithLimits({
    MessageManager: 50, // Limit message cache
    UserManager: 100,   // Limit user cache
    GuildMemberManager: 0 // Disable member cache if not needed
  })
});

// Periodic cache cleanup
setInterval(() => {
  client.guilds.cache.forEach(guild => {
    guild.members.cache.clear();
    guild.channels.cache.forEach(channel => {
      if (channel.messages) {
        channel.messages.cache.clear();
      }
    });
  });
}, 300000); // Every 5 minutes

import discord
from discord.ext import commands

# Optimize intents
intents = discord.Intents.default()
intents.message_content = True  # Only if needed
intents.members = False         # Disable if not needed
intents.presences = False       # Usually not needed

# Configure bot with optimizations
bot = commands.Bot(
    command_prefix='!',
    intents=intents,
    max_messages=50,  # Limit message cache
    chunk_guilds_at_startup=False,  # Don't fetch all members
    member_cache_flags=discord.MemberCacheFlags.none()  # Minimal member cache
)

# Memory cleanup task
@tasks.loop(minutes=5)
async def cleanup_cache():
    for guild in bot.guilds:
        guild._members.clear()
        for channel in guild.channels:
            if hasattr(channel, '_messages'):
                channel._messages.clear()

// PostgreSQL with connection pooling
const { Pool } = require('pg');

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 10,        // Maximum connections
  min: 2,         // Minimum connections
  idle: 30000,    // 30 seconds idle timeout
  acquire: 60000, // 60 seconds acquire timeout
  ssl: {
    rejectUnauthorized: false
  }
});

// Efficient query execution
async function getUserData(userId) {
  const client = await pool.connect();
  try {
    const result = await client.query(
      'SELECT * FROM users WHERE id = $1',
      [userId]
    );
    return result.rows[0];
  } finally {
    client.release();
  }
}

-- Create indexes for common queries
CREATE INDEX idx_users_discord_id ON users(discord_id);
CREATE INDEX idx_guilds_guild_id ON guild_settings(guild_id);
CREATE INDEX idx_messages_timestamp ON messages(timestamp DESC);
CREATE INDEX idx_warnings_user_guild ON warnings(user_id, guild_id);

-- Composite indexes for complex queries
CREATE INDEX idx_user_activity ON user_activity(guild_id, user_id, activity_date);

// Express.js health check
const express = require('express');
const app = express();

app.get('/health', async (req, res) => {
  const health = {
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    memory: process.memoryUsage(),
    discord: {
      status: client.ws.status,
      ping: client.ws.ping,
      guilds: client.guilds.cache.size,
      users: client.users.cache.size
    }
  };
  
  // Check database connection
  try {
    await pool.query('SELECT 1');
    health.database = 'connected';
  } catch (error) {
    health.database = 'error';
    health.status = 'degraded';
  }
  
  const statusCode = health.status === 'ok' ? 200 : 503;
  res.status(statusCode).json(health);
});

app.listen(process.env.PORT || 3000);

// Simple metrics tracking
class BotMetrics {
  constructor() {
    this.commandsExecuted = 0;
    this.errors = 0;
    this.responseTimeSum = 0;
    this.responseTimeCount = 0;
    this.startTime = Date.now();
  }
  
  recordCommand(executionTime) {
    this.commandsExecuted++;
    this.responseTimeSum += executionTime;
    this.responseTimeCount++;
  }
  
  recordError() {
    this.errors++;
  }
  
  getStats() {
    return {
      uptime: Date.now() - this.startTime,
      commandsExecuted: this.commandsExecuted,
      errors: this.errors,
      averageResponseTime: this.responseTimeCount > 0 
        ? this.responseTimeSum / this.responseTimeCount 
        : 0,
      errorRate: this.commandsExecuted > 0 
        ? (this.errors / this.commandsExecuted) * 100 
        : 0
    };
  }
}

const metrics = new BotMetrics();

// Usage in command handler
client.on('interactionCreate', async (interaction) => {
  if (!interaction.isChatInputCommand()) return;
  
  const start = Date.now();
  try {
    await handleCommand(interaction);
    metrics.recordCommand(Date.now() - start);
  } catch (error) {
    metrics.recordError();
    console.error('Command error:', error);
  }
});

// Monitor memory usage
setInterval(() => {
  const usage = process.memoryUsage();
  console.log({
    rss: `${Math.round(usage.rss / 1024 / 1024)} MB`,
    heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)} MB`,
    heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)} MB`,
    external: `${Math.round(usage.external / 1024 / 1024)} MB`
  });
}, 30000); // Every 30 seconds

// Detect memory leaks
if (process.env.NODE_ENV === 'development') {
  const v8 = require('v8');
  
  setInterval(() => {
    const heapSnapshot = v8.writeHeapSnapshot();
    console.log(`Heap snapshot written to ${heapSnapshot}`);
  }, 600000); // Every 10 minutes in development
}

# Docker Compose with scaling
version: '3.8'
services:
  discord-bot:
    image: your-bot:latest
    deploy:
      replicas: 1
      update_config:
        parallelism: 1
        order: start-first
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
        reservations:
          memory: 256M
          cpus: '0.25'
    environment:
      - DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN}
      - DATABASE_URL=${DATABASE_URL}

// Bot clustering for high availability
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  
  // Fork workers
  for (let i = 0; i < Math.min(numCPUs, 4); i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Restart failed worker
  });
} else {
  // Workers run the bot
  require('./bot.js');
  console.log(`Worker ${process.pid} started`);
}

// Use proper secrets management
const secrets = {
  discord: {
    token: process.env.DISCORD_BOT_TOKEN,
    clientId: process.env.DISCORD_CLIENT_ID,
    clientSecret: process.env.DISCORD_CLIENT_SECRET
  },
  database: {
    url: process.env.DATABASE_URL
  },
  encryption: {
    key: process.env.ENCRYPTION_KEY
  }
};

// Validate required secrets on startup
function validateSecrets() {
  const required = [
    'DISCORD_BOT_TOKEN',
    'DISCORD_CLIENT_ID',
    'DATABASE_URL'
  ];
  
  const missing = required.filter(key => !process.env[key]);
  
  if (missing.length > 0) {
    console.error(`Missing required environment variables: ${missing.join(', ')}`);
    process.exit(1);
  }
}

validateSecrets();

// Sanitize user inputs
const validator = require('validator');

function sanitizeInput(input) {
  if (typeof input !== 'string') return '';
  
  // Remove potential harmful characters
  return validator.escape(input)
    .replace(/[<>"'%]/g, '') // Remove HTML/script chars
    .substring(0, 2000); // Limit length
}

// Validate Discord IDs
function isValidDiscordId(id) {
  return /^\d{17,19}$/.test(id);
}

// Rate limiting
const rateLimits = new Map();

function checkRateLimit(userId, limit = 5, window = 60000) {
  const now = Date.now();
  const userLimits = rateLimits.get(userId) || [];
  
  // Remove old entries
  const validEntries = userLimits.filter(time => now - time < window);
  
  if (validEntries.length >= limit) {
    return false; // Rate limited
  }
  
  validEntries.push(now);
  rateLimits.set(userId, validEntries);
  return true; // Allow request
}

// Memory leak detection
class MemoryMonitor {
  constructor() {
    this.baseline = process.memoryUsage();
    this.samples = [];
    this.alertThreshold = 100; // MB growth
  }
  
  monitor() {
    const current = process.memoryUsage();
    const growth = (current.heapUsed - this.baseline.heapUsed) / 1024 / 1024;
    
    this.samples.push({
      timestamp: Date.now(),
      heapUsed: current.heapUsed,
      growth: growth
    });
    
    // Keep last 100 samples
    if (this.samples.length > 100) {
      this.samples.shift();
    }
    
    // Alert if consistent growth
    if (growth > this.alertThreshold) {
      console.warn(`Potential memory leak detected: ${growth.toFixed(2)}MB growth`);
      this.dumpTopGrowthAreas();
    }
  }
  
  dumpTopGrowthAreas() {
    // Implementation depends on your specific needs
    console.log('Memory usage by component:');
    console.log(`Discord.js cache: ${this.estimateDiscordCacheSize()}MB`);
    console.log(`Database connections: ${this.estimateDatabaseMemory()}MB`);
  }
}

const memoryMonitor = new MemoryMonitor();
setInterval(() => memoryMonitor.monitor(), 60000); // Every minute

// Robust connection handling
client.on('shardError', error => {
  console.error('A websocket connection encountered an error:', error);
});

client.on('shardReconnecting', id => {
  console.log(`Shard ${id} is reconnecting...`);
});

client.on('shardResume', (id, replayedEvents) => {
  console.log(`Shard ${id} resumed. Replayed ${replayedEvents} events.`);
});

// Database connection recovery
class DatabaseManager {
  constructor(connectionString) {
    this.connectionString = connectionString;
    this.pool = null;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
  }
  
  async connect() {
    try {
      this.pool = new Pool({ connectionString: this.connectionString });
      
      this.pool.on('error', (err) => {
        console.error('Database pool error:', err);
        this.handleConnectionError();
      });
      
      // Test connection
      await this.pool.query('SELECT 1');
      console.log('Database connected successfully');
      this.reconnectAttempts = 0;
      
    } catch (error) {
      console.error('Database connection failed:', error);
      await this.handleConnectionError();
    }
  }
  
  async handleConnectionError() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
      
      console.log(`Retrying database connection in ${delay}ms (attempt ${this.reconnectAttempts})`);
      
      setTimeout(() => this.connect(), delay);
    } else {
      console.error('Max reconnection attempts reached. Exiting.');
      process.exit(1);
    }
  }
}

#!/bin/bash
# Blue-green deployment script

set -e

NEW_IMAGE="your-bot:${BUILD_NUMBER}"
CURRENT_SERVICE="discord-bot-blue"
NEW_SERVICE="discord-bot-green"

echo "Deploying ${NEW_IMAGE}..."

# Deploy new version
docker service create \
  --name $NEW_SERVICE \
  --replicas 1 \
  --env DISCORD_BOT_TOKEN="$DISCORD_BOT_TOKEN" \
  --env DATABASE_URL="$DATABASE_URL" \
  $NEW_IMAGE

# Wait for health check
echo "Waiting for new service to be healthy..."
for i in {1..30}; do
  if curl -f http://new-service-url/health; then
    echo "New service is healthy"
    break
  fi
  sleep 10
done

# Switch traffic
echo "Switching traffic to new service..."
# Update load balancer configuration

# Remove old service
echo "Removing old service..."
docker service rm $CURRENT_SERVICE

echo "Deployment complete"

-- Safe database migrations
BEGIN;

-- Add new column with default value
ALTER TABLE users ADD COLUMN premium_tier INTEGER DEFAULT 0;

-- Create index concurrently (PostgreSQL)
CREATE INDEX CONCURRENTLY idx_users_premium_tier ON users(premium_tier);

-- Update existing data in batches
DO $$
DECLARE
    batch_size INTEGER := 1000;
    offset_val INTEGER := 0;
    updated_count INTEGER;
BEGIN
    LOOP
        UPDATE users 
        SET premium_tier = CASE 
            WHEN subscription_type = 'premium' THEN 1
            WHEN subscription_type = 'pro' THEN 2
            ELSE 0
        END
        WHERE id IN (
            SELECT id FROM users 
            ORDER BY id 
            LIMIT batch_size OFFSET offset_val
        );
        
        GET DIAGNOSTICS updated_count = ROW_COUNT;
        
        IF updated_count = 0 THEN
            EXIT;
        END IF;
        
        offset_val := offset_val + batch_size;
        
        -- Commit periodically
        IF offset_val % 10000 = 0 THEN
            COMMIT;
            BEGIN;
        END IF;
    END LOOP;
END $$;

COMMIT;

# kubernetes/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: discord-bot
  labels:
    app: discord-bot
spec:
  replicas: 2
  selector:
    matchLabels:
      app: discord-bot
  template:
    metadata:
      labels:
        app: discord-bot
    spec:
      containers:
      - name: bot
        image: your-registry/discord-bot:latest
        ports:
        - containerPort: 3000
        env:
        - name: DISCORD_BOT_TOKEN
          valueFrom:
            secretKeyRef:
              name: bot-secrets
              key: discord-token
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: bot-secrets
              key: database-url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: discord-bot-service
spec:
  selector:
    app: discord-bot
  ports:
  - port: 80
    targetPort: 3000
  type: ClusterIP

// Abstract cloud services
class CloudStorage {
  constructor(provider) {
    switch (provider) {
      case 'aws':
        this.client = new AWS.S3();
        break;
      case 'gcp':
        this.client = new Storage();
        break;
      case 'azure':
        this.client = new BlobServiceClient();
        break;
      default:
        throw new Error(`Unsupported provider: ${provider}`);
    }
  }
  
  async uploadFile(key, data) {
    // Provider-specific implementation
  }
  
  async downloadFile(key) {
    // Provider-specific implementation
  }
}

// Configuration-driven deployment
const config = {
  cloud: {
    provider: process.env.CLOUD_PROVIDER || 'railway',
    region: process.env.CLOUD_REGION || 'us-east1',
    storage: process.env.STORAGE_PROVIDER || 'postgresql'
  },
  bot: {
    shards: parseInt(process.env.SHARD_COUNT) || 1,
    clustering: process.env.ENABLE_CLUSTERING === 'true'
  }
};

// Bot hosting cost calculator
class HostingCostCalculator {
  constructor() {
    this.platforms = {
      railway: { base: 5, perGB: 0.1, perRequest: 0 },
      digitalocean: { base: 5, perGB: 0.02, perRequest: 0 },
      cloudrun: { base: 0, perGB: 0.24, perRequest: 0.0000004 },
      heroku: { base: 7, perGB: 0, perRequest: 0 },
      vps: { base: 5, perGB: 0, perRequest: 0 }
    };
  }
  
  calculateMonthlyCost(platform, specs) {
    const { memoryGB, requestsPerMonth, bandwidthGB } = specs;
    const pricing = this.platforms[platform];
    
    if (!pricing) {
      throw new Error(`Unknown platform: ${platform}`);
    }
    
    let cost = pricing.base;
    cost += memoryGB * pricing.perGB;
    cost += requestsPerMonth * pricing.perRequest;
    
    return {
      platform,
      monthlyCost: Math.round(cost * 100) / 100,
      breakdown: {
        base: pricing.base,
        memory: memoryGB * pricing.perGB,
        requests: requestsPerMonth * pricing.perRequest
      }
    };
  }
  
  compareAllPlatforms(specs) {
    return Object.keys(this.platforms).map(platform => 
      this.calculateMonthlyCost(platform, specs)
    ).sort((a, b) => a.monthlyCost - b.monthlyCost);
  }
}

// Usage example
const calculator = new HostingCostCalculator();
const specs = {
  memoryGB: 0.5,
  requestsPerMonth: 100000,
  bandwidthGB: 5
};

console.log(calculator.compareAllPlatforms(specs));